import traceback
import logging  # 添加这一行

import matplotlib.pyplot as plt
import pandas as pd
import streamlit as st
import numpy as np
import json

from config import load_config
from main import CareerAISystem
from region_cards import display_city_cards  # 导入城市卡片显示函数

# 初始化日志记录器
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger("AI职业导航系统")  # 添加这一行

# 设置Matplotlib中文字体支持
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'SimSun', 'Arial Unicode MS', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False  # 正确显示负号

# 设置页面配置
st.set_page_config(
    page_title="AI职业发展智能匹配系统",
    page_icon="🚀",
    layout="wide",
    initial_sidebar_state="expanded"
)

# 添加全局CSS样式
st.markdown("""
<style>
/* 预览容器样式 */
.preview-container {
    max-height: 250px;
    overflow-y: auto;
    border: 1px solid #e0e0e0;
    border-radius: 5px;
    padding: 15px;
    background-color: #f9f9f9;
    margin-bottom: 10px;
    font-family: monospace;
    white-space: pre-wrap;
    font-size: 0.9em;
}

/* 目标卡片样式 */
.goal-card {
    padding: 10px;
    background-color: #e8f4f8;
    border-radius: 5px;
    border-left: 3px solid #2196F3;
    margin-bottom: 10px;
}

/* 信息统计卡片 */
.info-card {
    padding: 10px;
    border-radius: 5px;
    background-color: #f5f7fa;
    margin-bottom: 10px;
    border-left: 3px solid #4caf50;
}
</style>
""", unsafe_allow_html=True)

# 加载配置
config = load_config()
system = CareerAISystem(config)

# 定义辅助函数 - 移到文件顶部
def _extract_basic_skills(resume_text):
    """从简历文本中提取基本技能
    
    Args:
        resume_text (str): 简历文本
        
    Returns:
        dict: 提取的技能和估计水平
    """
    # 预定义的技能关键词及其默认分数
    skill_keywords = {
        'python': 75, 'java': 70, 'c++': 70, 'javascript': 70, 'sql': 70,
        'pandas': 75, 'numpy': 75, 'matplotlib': 70, 'tensorflow': 70, 
        'scikit-learn': 70, 'pytorch': 70, 'spark': 70, 'hadoop': 65,
        'git': 65, 'docker': 65, 'kubernetes': 65, 'linux': 65,
        'aws': 70, 'azure': 70, 'gcp': 70, 'react': 70, 'vue': 70,
        'django': 70, 'flask': 70, 'nodejs': 70, 'mongodb': 70,
        'machine learning': 75, 'deep learning': 75, 'data analysis': 75,
        'data science': 75, 'data mining': 70, 'nlp': 75
    }
    
    # 技能水平关键词调整
    level_adjustments = {
        '精通': 20, '熟练': 15, '熟悉': 10, '了解': 0, '基础': -5,
        'expert': 20, 'proficient': 15, 'familiar': 10, 'basic': -5
    }
    
    # 转为小写以进行不区分大小写的匹配
    resume_lower = resume_text.lower()
    
    # 提取找到的技能
    found_skills = {}
    
    for skill, base_score in skill_keywords.items():
        if skill in resume_lower:
            # 默认分数
            score = base_score
            
            # 检查是否有技能水平描述
            for level, adjustment in level_adjustments.items():
                if level in resume_lower and resume_lower.find(level) < resume_lower.find(skill) + 20 and resume_lower.find(level) > resume_lower.find(skill) - 20:
                    score += adjustment
                    break
            
            # 确保分数在有效范围内
            score = max(30, min(score, 95))
            found_skills[skill.title()] = score
    
    # 如果没有找到任何技能，返回一些基本技能
    if not found_skills:
        return {'Python': 70, 'SQL': 65, 'Data Analysis': 65}
    
    return found_skills

def _extract_basic_skills_enhanced(resume_text):
    """增强版从简历文本中提取基本技能
    
    Args:
        resume_text (str): 简历文本
        
    Returns:
        dict: 提取的技能和估计水平
    """
    # 扩展技能关键词词典，包含中英文技能名称
    skill_keywords = {
        # 编程语言
        'python': 75, 'java': 70, 'c++': 70, 'javascript': 70, 'typescript': 70,
        'c#': 70, 'go': 75, 'php': 70, 'ruby': 70, 'swift': 70, 'r语言': 70, 'r': 70,
        
        # 数据相关
        'sql': 70, 'mysql': 70, 'postgresql': 70, 'mongodb': 70, 'redis': 70,
        'oracle': 75, 'sqlite': 65, '数据库': 70, '数据仓库': 75, 
        '数据建模': 75, '数据挖掘': 75, '数据分析': 75, '数据可视化': 70,
        
        # 数据科学/AI
        'pandas': 75, 'numpy': 75, 'scipy': 70, 'matplotlib': 70, 'scikit-learn': 70,
        'sklearn': 70, 'pytorch': 75, 'tensorflow': 75, '机器学习': 75, 'excel': 65,
        '深度学习': 80, '神经网络': 75, 'nlp': 75, '自然语言处理': 75,
        '计算机视觉': 75, 'cv': 75, '强化学习': 80, '推荐系统': 75,
        
        # 大数据
        'hadoop': 75, 'spark': 75, 'hive': 70, 'flink': 75, 'kafka': 70,
        
        # Web开发
        'html': 65, 'css': 65, 'react': 70, 'vue': 70, 'angular': 70,
        'django': 70, 'flask': 70, 'spring': 70, 'bootstrap': 65,
        
        # 工具和平台
        'git': 65, 'docker': 70, 'kubernetes': 75, 'linux': 65, 'aws': 70, 
        'azure': 70, '阿里云': 70, '腾讯云': 70, 'tableau': 70, 'power bi': 70,
        
        # 软技能
        '沟通能力': 70, '团队协作': 70, '项目管理': 70, '解决问题': 70
    }
    
    # 转为小写以进行不区分大小写的匹配
    resume_lower = resume_text.lower()
    
    # 提取找到的技能
    found_skills = {}
    
    for skill, base_score in skill_keywords.items():
        if skill in resume_lower:
            # 技能出现在简历中，默认评分为基础分数
            found_skills[skill.title()] = base_score
    
    # 如果没有找到任何技能，返回一些基本技能
    if not found_skills:
        # 根据简历中可能包含的关键词推断基本技能
        if '数据' in resume_lower or '分析' in resume_lower:
            return {'Python': 65, 'SQL': 70, '数据分析': 75, '数据可视化': 65}
        elif '开发' in resume_lower or '编程' in resume_lower:
            return {'Python': 70, 'Java': 65, 'JavaScript': 65, 'Git': 60}
        elif '设计' in resume_lower:
            return {'UI设计': 70, 'Photoshop': 65, '用户体验': 70}
        elif '产品' in resume_lower:
            return {'产品管理': 70, '需求分析': 65, '用户研究': 60}
        elif '市场' in resume_lower or '营销' in resume_lower:
            return {'市场分析': 70, '营销策略': 65, '社交媒体': 70}
        else:
            return {'办公软件': 70, '沟通能力': 65, '团队协作': 70}
    
    return found_skills

# 添加预览函数到这里，确保在任何页面函数之前定义它
def show_profile_preview(expanded=False):
    """显示统一样式的个人信息预览
    
    Args:
        expanded (bool): 是否默认展开预览
    """
    with st.expander("当前配置信息预览", expanded=expanded):
        # 基本信息摘要
        col1, col2 = st.columns(2)
        with col1:
            st.info(f"📄 简历字数：{len(st.session_state.get('resume_text', ''))}字")
            
            # 职业目标预览
            if st.session_state.get('career_goals'):
                st.markdown("##### 您的职业目标")
                st.markdown(f"""
                <div style="padding:8px; background-color:#f0f7ff; border-radius:5px; border-left:3px solid #2196F3;">
                    <i>"{st.session_state.get('career_goals')}"</i>
                </div>
                """, unsafe_allow_html=True)
                
        with col2:
            st.info(f"💼 目标职位字数：{len(st.session_state.get('job_desc', ''))}字")
            st.info(f"⏱️ 学习计划时长：{st.session_state.get('timeline_display', '3个月')}")
        
        # 添加一个下拉框让用户查看详细内容
        option = st.selectbox(
            "选择查看详细内容",
            ["选择查看...", "简历详情", "职位详情", "全部内容"],
            key=f"profile_detail_selector_{st.session_state.get('_current_page', 'default')}"
        )
        
        # 根据选择显示相应内容
        if option == "简历详情" or option == "全部内容":
            st.markdown("##### 简历内容")
            resume_text = st.session_state.get('resume_text', '')
            st.markdown(f"""
            <div class="preview-container">
            {resume_text}
            </div>
            """, unsafe_allow_html=True)
            
        if option == "职位详情" or option == "全部内容":
            st.markdown("##### 职位描述")
            job_desc = st.session_state.get('job_desc', '')
            st.markdown(f"""
            <div class="preview-container">
            {job_desc}
            </div>
            """, unsafe_allow_html=True)

# 首先定义所有页面函数和辅助函数
def user_profile_page():
    st.title("个人信息与职业目标配置")
    
    # 添加说明
    st.info("在此页面统一配置您的个人信息和职业目标，所有模块将共享这些信息进行分析。")
    
    # 添加示例选择区域
    with st.expander("选择行业示例", expanded=True):
        st.write("您可以选择以下行业的示例数据进行体验：")
        
        # 定义不同行业的示例数据
        industry_examples = {
            "选择示例...": {
                "resume": "",
                "job_desc": "",
                "career_goals": "",
                "timeline": 3
            },
            "数据分析/数据科学": {
                "resume": """
姓名：王明
学历：北京大学，数据科学与大数据技术专业，硕士学位，2020年毕业

工作经验：
- 数据分析师 | ABC科技有限公司 | 2020年7月至今
  负责用户行为数据分析，构建数据可视化仪表板，提供数据驱动的产品优化建议
  使用Python、SQL进行数据分析，利用Tableau进行数据可视化
  开发了用户留存预测模型，准确率提升15%

- 数据分析实习生 | XYZ互联网公司 | 2019年7月至2020年1月
  协助团队进行市场数据分析，参与用户画像系统搭建
  使用pandas、numpy进行数据处理，使用matplotlib、seaborn进行可视化

技能：
- 编程语言：Python（熟练），SQL（精通），R（了解）
- 数据分析工具：pandas, numpy, scipy
- 数据可视化：Tableau, matplotlib, seaborn
- 机器学习：scikit-learn, 熟悉常见的分类、回归算法
- 数据库：MySQL, MongoDB
- 英语：CET-6，良好的读写能力

项目经历：
1. 用户流失预测模型 - 使用机器学习算法分析用户行为数据，预测可能流失的用户，准确率达82%
2. 销售数据分析仪表板 - 使用Tableau构建实时销售数据分析系统，帮助业务团队提升决策效率

证书：
- 数据分析师专业认证
- Python数据科学全栈工程师认证
                """,
                "job_desc": """
职位名称：高级数据分析师

职位描述：
我们正在寻找一位经验丰富的高级数据分析师，加入我们的数据团队。您将负责分析复杂的数据集，提供有价值的业务洞察，并支持公司的数据驱动决策。

工作职责：
- 收集、处理和分析大量数据，识别趋势和模式
- 构建高效的数据可视化报表和仪表板
- 开发预测模型，为业务决策提供支持
- 与产品、营销和业务团队合作，解决数据相关问题
- 优化数据收集流程和报告系统
- 培训和指导初级分析师

任职要求：
- 3年以上相关数据分析工作经验
- 精通SQL，能够编写复杂查询
- 熟练掌握Python及相关数据分析库（pandas, numpy等）
- 熟悉数据可视化工具，如Tableau, Power BI等
- 熟悉基础机器学习算法和统计分析方法
- 良好的沟通能力和团队协作精神
- 统计学、计算机科学、数学或相关领域学士以上学位

加分项：
- 有电子商务或SaaS行业经验
- 熟悉A/B测试设计与分析
- 具备云平台数据处理经验（AWS, Azure, GCP）
- 熟悉大数据工具如Hadoop, Spark
                """,
                "career_goals": "3年内成为数据科学团队负责人，带领团队构建高影响力的机器学习产品",
                "timeline": 12
            },
            "软件开发/工程": {
                "resume": """
姓名：张伟
学历：清华大学，计算机科学与技术专业，本科，2019年毕业

工作经验：
- 后端开发工程师 | DEF科技有限公司 | 2019年7月至今
  负责公司核心API服务的设计和开发，完成了微服务架构改造
  使用Java Spring Boot框架开发RESTful API
  优化了数据库查询性能，减少了50%的响应时间
  参与代码评审，保证代码质量

- 软件开发实习生 | GHI软件公司 | 2018年7月至2019年1月
  参与电商平台后端开发，实现订单管理和支付系统对接
  使用Java和MySQL开发业务功能模块

技能：
- 编程语言：Java（精通），Python（熟练），JavaScript（熟悉）
- 后端框架：Spring Boot, Spring Cloud, MyBatis
- 数据库：MySQL, Redis, MongoDB
- DevOps：Git, Docker, Jenkins, Kubernetes
- 微服务：服务注册发现、配置中心、API网关、负载均衡
- 英语：CET-6，良好的读写能力

项目经历：
1. 微服务架构改造 - 将单体应用拆分为微服务架构，提升了系统扩展性和可维护性
2. 实时消息推送系统 - 设计并实现基于WebSocket的实时消息推送系统，支持百万级用户同时在线
3. 分布式任务调度平台 - 开发分布式任务调度系统，支持任务动态分配和失败重试

证书：
- Oracle认证Java专业程序员
- AWS解决方案架构师助理级认证
                """,
                "job_desc": """
职位名称：高级Java开发工程师

职位描述：
我们正在寻找一位有经验的高级Java开发工程师，加入我们的技术团队。您将负责设计和开发高性能、可扩展的企业级应用程序，参与整个软件开发生命周期。

工作职责：
- 负责公司核心业务系统的设计、开发和维护
- 参与技术方案设计，提供技术可行性分析
- 编写高质量、可维护的代码，并进行单元测试
- 优化应用性能，解决技术难题
- 参与代码评审，指导初级开发人员
- 持续关注新技术，并在适当时机引入到项目中

任职要求：
- 5年以上Java开发经验，扎实的编程功底
- 精通Java核心技术，熟悉JVM调优
- 熟练掌握Spring框架生态（Spring Boot, Spring Cloud等）
- 熟悉分布式系统设计和微服务架构
- 熟练使用关系型数据库（MySQL/PostgreSQL）和NoSQL数据库
- 了解DevOps工具链和容器化技术（Docker, Kubernetes）
- 良好的沟通能力和团队协作精神
- 计算机相关专业本科及以上学历

加分项：
- 有大型电商或金融系统开发经验
- 熟悉高并发、高可用系统设计
- 有开源项目贡献经验
- 熟悉云原生应用开发
                """,
                "career_goals": "5年内成为技术架构师，主导大型分布式系统架构设计，提升个人技术影响力",
                "timeline": 18
            },
            "人工智能/机器学习": {
                "resume": """
姓名：李梅
学历：中国科学院大学，人工智能专业，博士学位，2021年毕业

工作经验：
- 机器学习工程师 | JKL人工智能公司 | 2021年7月至今
  负责开发和优化计算机视觉算法，提高物体检测和图像分割精度
  使用PyTorch框架设计和实现深度学习模型
  优化模型推理性能，实现边缘设备部署

- 研究实习生 | MNO研究院 | 2020年1月至2021年6月
  研究计算机视觉领域的前沿技术，发表2篇学术论文
  实现多种目标检测和图像分割算法

技能：
- 编程语言：Python（精通），C++（熟练）
- 深度学习框架：PyTorch（精通），TensorFlow（熟练）
- 计算机视觉：目标检测、图像分割、姿态估计
- 机器学习：分类、回归、聚类、强化学习
- GPU加速：CUDA编程
- 论文研读与复现能力强
- 英语：专业级读写能力，发表过英文论文

项目经历：
1. 实时行人检测系统 - 开发了基于YOLOv5的行人检测系统，在边缘设备上达到25FPS
2. 医学图像分割工具 - 使用U-Net变体实现医学影像的精确分割，Dice系数达到0.92
3. 视频异常行为检测 - 设计基于时空特征的异常行为检测算法，准确率提升15%

发表论文：
1. "Efficient Attention Mechanism for Real-time Object Detection", CVPR 2021
2. "Multi-scale Feature Fusion for Medical Image Segmentation", MICCAI 2020

证书：
- NVIDIA深度学习认证
- 谷歌TensorFlow开发者认证
                """,
                "job_desc": """
职位名称：高级机器学习研究员

职位描述：
我们正在寻找一位高级机器学习研究员，加入我们的AI研究团队。您将研究和开发前沿的机器学习算法，解决复杂的实际问题，推动公司AI技术创新。

工作职责：
- 研究和开发先进的机器学习和深度学习算法
- 解决计算机视觉、自然语言处理等领域的关键技术挑战
- 将研究成果转化为可用的产品和服务
- 跟踪AI领域最新进展，提出创新性技术方案
- 发表高质量的研究论文，申请技术专利
- 与工程团队合作，确保算法的实际落地

任职要求：
- 计算机科学、人工智能或相关领域博士学位
- 3年以上机器学习算法研究或开发经验
- 精通深度学习框架（PyTorch或TensorFlow）
- 在计算机视觉或自然语言处理领域有专长
- 有高质量论文发表经历或顶级AI竞赛获奖经历
- 具备将算法从研究转化为工程实践的能力
- 优秀的问题解决能力和逻辑思维能力

加分项：
- 在顶级会议（如CVPR、NeurIPS、ICLR等）发表过论文
- 有开源项目贡献或维护经验
- 熟悉模型压缩、量化和加速技术
- 有大规模机器学习系统开发经验
                """,
                "career_goals": "成为AI领域的技术专家，发表高影响力论文，领导前沿技术研发",
                "timeline": 24
            },
            "产品/设计": {
                "resume": """
姓名：陈晓
学历：浙江大学，交互设计专业，本科学位，2018年毕业

工作经验：
- 产品经理 | PQR科技有限公司 | 2020年3月至今
  负责移动应用产品规划和迭代，撰写产品需求文档
  主导用户研究，分析用户反馈，优化产品体验
  与设计、开发团队密切合作，推动产品落地
  通过A/B测试优化转化率，核心功能使用率提升30%

- UI/UX设计师 | STU设计工作室 | 2018年7月至2020年2月
  负责移动应用和网站的界面设计和用户体验设计
  创建用户流程、原型和高保真界面设计
  参与用户测试和设计评审

技能：
- 产品设计：用户故事地图、用户旅程、产品原型设计
- 设计工具：Figma, Sketch, Adobe XD
- 原型工具：Axure RP, InVision, ProtoPie
- 数据分析：熟悉数据驱动设计，能使用基础数据分析工具
- 项目管理：Jira, Trello, Asana
- 沟通协作：良好的跨团队沟通能力，能够协调多方资源

项目经历：
1. 社交媒体应用改版 - 负责产品重新设计，用户留存率提升25%
2. 电商平台用户体验优化 - 简化购买流程，转化率提升15%
3. 企业协作工具设计 - 从0到1主导设计协作工具，获得5000+企业用户

证书：
- 认证产品经理（CPM）
- 用户体验设计师认证
                """,
                "job_desc": """
职位名称：高级产品经理

职位描述：
我们正在寻找一位有经验的高级产品经理，负责我们的核心产品线规划和发展。您将负责定义产品愿景，规划路线图，并与跨职能团队合作将想法转化为成功的产品。

工作职责：
- 负责产品的全生命周期管理，包括规划、开发和发布
- 进行市场研究和用户调研，确定产品机会和需求
- 撰写详细的产品需求文档（PRD）和用户故事
- 与设计和开发团队紧密合作，确保产品按计划交付
- 分析产品数据，提出优化建议，持续提升用户体验
- 跟踪竞品动态，保持产品的市场竞争力
- 协调跨部门资源，推动产品目标达成

任职要求：
- 5年以上互联网/软件产品经理经验
- 出色的产品思维和用户体验敏感度
- 优秀的沟通能力和项目管理能力
- 能够使用数据分析工具，具备数据驱动决策能力
- 熟悉敏捷开发流程，有带领团队经验
- 优秀的文档写作能力，能够清晰表达产品需求
- 本科及以上学历，计算机、设计或商业相关专业优先

加分项：
- 有SaaS或企业服务产品经验
- 具备基础的UI/UX设计技能
- 了解基础编程知识，能与技术团队高效沟通
- 有成功的产品从0到1的经验
                """,
                "career_goals": "未来希望成为产品总监，主导创新产品策略，打造影响数百万用户的爆款产品",
                "timeline": 12
            },
            "市场/营销": {
                "resume": """
姓名：赵晨
学历：复旦大学，市场营销专业，硕士学位，2017年毕业

工作经验：
- 数字营销经理 | VWX营销公司 | 2019年5月至今
  负责制定数字营销策略，管理多个客户的营销活动
  规划和执行社交媒体营销、内容营销和影响力营销
  管理Google Ads和社交媒体广告投放，优化ROI
  分析营销数据，优化活动效果，为客户提供数据报告

- 内容营销专员 | YZA互联网公司 | 2017年7月至2019年4月
  负责公司官方博客和社交媒体内容创作
  开发SEO优化内容，提升网站自然流量
  协助Email营销活动设计和执行

技能：
- 数字营销：SEO/SEM, 内容营销, 社交媒体营销
- 广告投放：Google Ads, Facebook Ads, 小红书, 抖音
- 数据分析：Google Analytics, 营销漏斗分析
- 营销工具：Mailchimp, HubSpot, Hootsuite
- 内容创作：博客写作, 文案策划, 基础平面设计
- 项目管理：营销活动规划与执行, 预算管理

项目经历：
1. 电商品牌双十一营销活动 - 策划并执行全渠道营销活动，销售额环比提升150%
2. SaaS产品内容营销体系搭建 - 建立内容营销矩阵，自然流量提升200%
3. B2B企业品牌重塑 - 负责品牌重塑传播策略，品牌知名度提升35%

证书：
- Google数字营销认证
- HubSpot内容营销认证
- Facebook Blueprint认证
                """,
                "job_desc": """
职位名称：高级数字营销经理

职位描述：
我们正在寻找一位有经验的高级数字营销经理，负责规划和执行公司全方位的数字营销策略。您将领导营销团队，提升品牌知名度，增加用户获取，并优化营销漏斗转化。

工作职责：
- 制定全面的数字营销策略，包括SEO/SEM、社交媒体、邮件营销等
- 管理并优化营销渠道组合，确保营销预算的高效使用
- 领导内容营销团队，制定内容策略和编辑日历
- 规划和执行用户获取和留存活动，提升产品转化和留存率
- 建立数据驱动的营销分析体系，评估各渠道ROI
- 管理营销团队，制定明确的KPI和绩效指标
- 与产品、销售团队紧密合作，确保营销与业务目标一致

任职要求：
- 6年以上数字营销经验，其中3年以上团队管理经验
- 丰富的全渠道数字营销经验，包括SEO/SEM、社交媒体、内容营销等
- 深入了解营销漏斗和用户转化路径优化
- 优秀的数据分析能力，能根据数据调整营销策略
- 出色的项目管理能力，能同时管理多个营销项目
- 优秀的团队领导力和沟通协调能力
- 市场营销、传播或相关专业本科及以上学历

加分项：
- 有SaaS或互联网产品营销经验
- 熟悉增长黑客方法论和A/B测试
- 具备基础用户增长和产品运营知识
- 有国际市场营销经验
                """,
                "career_goals": "希望在3年内成为营销总监，负责品牌策略和全球市场拓展，打造数据驱动的营销体系",
                "timeline": 15
            }
        }
        
        # 创建行业选择下拉框
        col1, col2 = st.columns([3, 1])
        with col1:
            selected_industry = st.selectbox("选择行业示例", list(industry_examples.keys()))
        
        with col2:
            if selected_industry != "选择示例..." and st.button("使用此示例"):
                example = industry_examples[selected_industry]
                # 将示例数据放入session state
                st.session_state.example_resume = example["resume"]
                st.session_state.example_job_desc = example["job_desc"]
                st.session_state.example_career_goals = example["career_goals"]
                st.session_state.example_timeline = example["timeline"]
                st.success(f"""已加载"{selected_industry}"行业示例""")
    
    # 使用card样式美化界面
    with st.container():
        st.subheader("🧑‍💼 个人信息")
        
        # 添加表单以保存所有配置
        with st.form("profile_form"):
            # 简历信息
            resume_text = st.text_area(
                "个人简历", 
                value=st.session_state.get('example_resume', st.session_state.get('resume_text', '')),
                placeholder="请输入您的教育背景、工作经验、项目经历和技能清单等。\n\n例如：\n姓名：张明\n教育背景：北京大学，计算机科学与技术专业\n工作经验：数据分析师 - ABC科技有限公司\n技能清单：Python（熟练），SQL（精通），机器学习...", 
                height=300
            )
            
            # 职位描述
            job_desc = st.text_area(
                "目标职位描述", 
                value=st.session_state.get('example_job_desc', st.session_state.get('job_desc', '')),
                placeholder="请输入职位名称、职责描述、任职要求等信息。\n\n例如：\n高级数据分析师\n任职要求：\n- 3年以上数据分析相关工作经验\n- 精通SQL和Python，熟悉pandas, numpy\n- 熟练掌握数据可视化工具", 
                height=250
            )
            
            # 职业目标
            career_goals = st.text_input(
                "职业目标", 
                value=st.session_state.get('example_career_goals', st.session_state.get('career_goals', '')),
                placeholder="例如：3年内成为数据科学团队负责人"
            )
            
            # 使用列布局添加更多选项
            col1, col2 = st.columns(2)
            
            with col1:
                # 时间单位选择
                time_unit = st.selectbox(
                    "时间单位",
                    options=["月", "周", "年", "日"],
                    index=0
                )
            
            with col2:
                # 获取示例时长或默认值
                default_timeline = st.session_state.get('example_timeline', 3)
                
                # 时间数值，根据单位调整范围
                if time_unit == "年":
                    timeline_value = st.slider("计划时长", 1, 5, min(default_timeline // 12, 5) if default_timeline else 1)
                elif time_unit == "月":
                    timeline_value = st.slider("计划时长", 1, 24, min(default_timeline, 24) if default_timeline else 3)
                elif time_unit == "周":
                    timeline_value = st.slider("计划时长", 1, 52, min(default_timeline * 4, 52) if default_timeline else 12)
                else:  # 日
                    timeline_value = st.slider("计划时长", 7, 180, min(default_timeline * 30, 180) if default_timeline else 30)
            
            # 转换为月份单位存储(系统内部统一用月作单位)
            if time_unit == "年":
                timeline_months = timeline_value * 12
            elif time_unit == "月":
                timeline_months = timeline_value
            elif time_unit == "周":
                timeline_months = round(timeline_value * 7 / 30, 1)
            else:  # 日
                timeline_months = round(timeline_value / 30, 1)
            
            # 添加美化的保存按钮
            st.markdown("""
            <style>
            div.stButton > button {
                background-color: #4CAF50;
                color: white;
                font-weight: bold;
                border: none;
                border-radius: 4px;
                padding: 10px 20px;
                margin: 10px 0;
            }
            div.stButton > button:hover {
                background-color: #45a049;
            }
            </style>
            """, unsafe_allow_html=True)
            
            submitted = st.form_submit_button("保存配置")
            
            if submitted:
                # 保存到session state
                st.session_state.resume_text = resume_text
                st.session_state.job_desc = job_desc
                st.session_state.career_goals = career_goals
                st.session_state.timeline_months = timeline_months
                st.session_state.timeline_display = f"{timeline_value} {time_unit}"
                
                # 清除示例缓存，防止下次加载时混淆
                if 'example_resume' in st.session_state:
                    del st.session_state.example_resume
                if 'example_job_desc' in st.session_state:
                    del st.session_state.example_job_desc
                if 'example_career_goals' in st.session_state:
                    del st.session_state.example_career_goals
                if 'example_timeline' in st.session_state:
                    del st.session_state.example_timeline
                
                # 显示成功消息
                st.success(f"✅ 配置已保存！计划时长设置为{timeline_value}{time_unit}（约{timeline_months}个月）")
                
                # 提供快速导航到首页分析的按钮
                st.markdown("""
                <div style="margin-top:20px;">
                <a href="#开始分析" target="_self" 
                   style="background-color:#1E88E5; color:white; padding:8px 16px; 
                   text-decoration:none; border-radius:4px; font-weight:bold;">
                   🚀 前往首页开始分析
                </a>
                </div>
                """, unsafe_allow_html=True)

def home_page():
    st.title("AI职业导航系统")
    
    # 检查是否已有配置信息
    if not (st.session_state.get('resume_text') and st.session_state.get('job_desc')):
        st.warning("⚠️ 请先在「个人配置」中设置您的简历和目标职位信息")
        return
    
    # 显示当前配置信息概要
    with st.expander("当前配置信息", expanded=True):
        col1, col2 = st.columns(2)
        with col1:
            st.info(f"📄 简历字数：{len(st.session_state.get('resume_text', ''))}字")
            st.info(f"🎯 职业目标：{st.session_state.get('career_goals', '未设置')}")
        with col2:
            st.info(f"💼 目标职位字数：{len(st.session_state.get('job_desc', ''))}字")
            st.info(f"⏱️ 学习计划时长：{st.session_state.get('timeline_display', '3个月')}")
    
    # 创建分析按钮
    analyze_button = st.button("🚀 开始全面分析", key="start_analysis", 
                             help="点击开始全面分析，生成完整报告")
    
    # 处理分析逻辑
    if analyze_button:
        with st.spinner("🔄 正在生成您的职业发展完整报告，这可能需要一些时间..."):
            try:
                # 从session state获取配置信息
                resume_text = st.session_state.get('resume_text', '')
                job_desc = st.session_state.get('job_desc', '')
                career_goals = st.session_state.get('career_goals', '')
                timeline = st.session_state.get('timeline_months', 3)
                
                # 运行完整分析流程
                results = system.run_full_pipeline(resume_text, job_desc, career_goals, timeline)
                
                # 保存结果到session state
                st.session_state.results = results
                st.session_state.analysis_completed = True
                
                # 显示成功消息
                st.success("✅ 分析完成！下面是您的职业发展完整报告")
                
                # 显示完整的分析报告
                display_full_report(results)
                
            except Exception as e:
                st.error(f"❌ 分析过程中发生错误: {str(e)}")
                import traceback
                st.error(traceback.format_exc())
    
    # 如果已有分析结果但未显示，直接显示
    elif st.session_state.get('analysis_completed') and st.session_state.get('results'):
        st.success("✅ 已完成分析，以下是您的职业发展完整报告")
        display_full_report(st.session_state.results)
    else:
        # 显示系统介绍信息
        st.markdown("""
        ## 欢迎使用AI职业导航系统
        
        本系统利用AI技术分析您的简历和目标职位，提供个性化的职业发展建议。
        
        ### 使用流程:
        1. **个人配置**：设置您的简历、目标职位和职业目标
        2. **一键分析**：点击"开始全面分析"按钮，生成完整报告
        3. **查看报告**：查看分析结果，了解您的职业发展路径
        
        点击上方的"开始全面分析"按钮，开启您的职业导航之旅！
        """)

def display_full_report(results):
    """显示完整的分析报告"""
    
    # 创建选项卡，组织报告内容
    tab1, tab2, tab3, tab4 = st.tabs(["技能匹配分析", "行业趋势", "职业发展路径", "学习计划"])
    
    with tab1:
        # 显示技能匹配分析
        st.subheader("技能匹配分析")
        
        # 提取匹配分析数据
        match_analysis = results.get('match_analysis', {})
        
        # 显示总体匹配度
        if 'overall_match' in match_analysis:
            overall_match = match_analysis['overall_match']
            
            # 设置匹配度颜色
            if overall_match >= 80:
                match_color = "#4CAF50"  # 绿色
                match_icon = "🌟"
                match_text = "非常匹配"
            elif overall_match >= 60:
                match_color = "#FF9800"  # 橙色
                match_icon = "⭐"
                match_text = "良好匹配"
            else:
                match_color = "#F44336"  # 红色
                match_icon = "⚠️"
                match_text = "需要提升"
            
            # 显示匹配度卡片
            st.markdown(f"""
            <div style="display:flex; align-items:center; padding:15px; background-color:#f8f9fa; border-radius:10px; margin-bottom:20px;">
                <div style="font-size:48px; font-weight:bold; color:{match_color}; margin-right:20px;">{overall_match}%</div>
                <div>
                    <div style="font-size:20px;">{match_icon} <b>{match_text}</b></div>
                    <div style="color:#666;">总体职位匹配度</div>
                </div>
            </div>
            """, unsafe_allow_html=True)
        
        # 创建两列布局
        col1, col2 = st.columns([3, 2])
        
        with col1:
            # 显示技能雷达图
            if match_analysis.get('match_analysis'):
                try:
                    # 提取技能数据
                    match_details = match_analysis['match_analysis']
                    
                    # 准备雷达图数据
                    import matplotlib.pyplot as plt
                    import numpy as np
                    
                    # 提取前5个关键技能
                    skills = list(match_details.keys())[:5]
                    if skills:
                        user_levels = [match_details[s].get('user_level', 0) for s in skills]
                        job_levels = [match_details[s].get('job_requirement', 0) for s in skills]
                        
                        # 创建雷达图
                        fig = plt.figure(figsize=(8, 6))
                        ax = fig.add_subplot(111, polar=True)
                        
                        # 计算角度
                        angles = np.linspace(0, 2*np.pi, len(skills), endpoint=False).tolist()
                        
                        # 闭合图形
                        skills = skills + [skills[0]]
                        angles = angles + [angles[0]]
                        user_levels = user_levels + [user_levels[0]]
                        job_levels = job_levels + [job_levels[0]]
                        
                        # 绘制用户技能水平
                        ax.plot(angles, user_levels, 'o-', linewidth=2, label='您的水平', color='#4CAF50')
                        ax.fill(angles, user_levels, alpha=0.25, color='#4CAF50')
                        
                        # 绘制职位要求水平
                        ax.plot(angles, job_levels, 'o-', linewidth=2, label='职位要求', color='#2196F3')
                        ax.fill(angles, job_levels, alpha=0.1, color='#2196F3')
                        
                        # 设置刻度和网格
                        ax.set_xticks(angles[:-1])
                        ax.set_xticklabels(skills[:-1], fontsize=10, fontweight='bold')
                        ax.set_ylim(0, 100)
                        
                        # 添加图例
                        plt.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1))
                        
                        st.pyplot(fig)
                    else:
                        st.info("没有足够的技能数据生成雷达图")
                except Exception as e:
                    st.error(f"生成雷达图时出错: {str(e)}")
        
        with col2:
            # 显示竞争力分析
            if 'competitiveness_analysis' in match_analysis:
                st.markdown("### 就业竞争力分析")
                st.markdown(f"""
                <div style="background-color:#f0f7ff; padding:15px; border-radius:10px; 
                            border-left:5px solid {match_color}; margin-bottom:20px;">
                    {match_analysis['competitiveness_analysis']}
                </div>
                """, unsafe_allow_html=True)
        
        # 显示技能差距详情表格
        if match_analysis.get('match_analysis'):
            st.markdown("### 技能差距详情")
            
            # 创建表格数据
            match_data = []
            for skill, data in match_analysis['match_analysis'].items():
                if isinstance(data, dict):
                    match_data.append({
                        "技能": skill,
                        "您的水平": data.get('user_level', 0),
                        "职位要求": data.get('job_requirement', 0),
                        "差距": data.get('gap', 0),
                        "匹配度": f"{data.get('match_percentage', 0):.1f}%"
                    })
            
            if match_data:
                # 转换为DataFrame并显示
                import pandas as pd
                match_df = pd.DataFrame(match_data)
                st.dataframe(match_df, use_container_width=True, hide_index=True)
        
        # 显示提升建议
        if 'improvement_suggestions' in match_analysis:
            st.markdown("### 提升建议")
            
            suggestions = match_analysis['improvement_suggestions']
            if isinstance(suggestions, list) and suggestions:
                for i, suggestion in enumerate(suggestions, 1):
                    st.markdown(f"""
                    <div style="background-color:#f0f7ff; padding:10px; border-radius:5px; 
                                margin-bottom:10px; border-left:3px solid #3b82f6;">
                        <strong>{i}.</strong> {suggestion}
                    </div>
                    """, unsafe_allow_html=True)
    
    with tab2:
        # 显示行业趋势分析
        st.subheader("行业趋势分析")
        
        trend_analysis = results.get('trend_analysis', {})
        
        if trend_analysis:
            # 显示行业信息
            industry = trend_analysis.get('industry', '信息技术')
            # 修改：直接使用内容，不显示占位符文本
            industry_description = trend_analysis.get('description', '')
            
            st.markdown(f"""
            <div style="background-color:#f0f7ff; padding:20px; border-radius:10px; margin-bottom:25px;">
                <h2 style="margin-top:0; color:#1e3a8a;">{industry}行业分析</h2>
                <p style="font-size:16px; color:#4b5563;">{industry_description}</p>
            </div>
            """, unsafe_allow_html=True)
            
            # 创建行业概览表格
            st.subheader("📊 行业发展概览")

            # 从分析结果中获取关键指标
            market_size = trend_analysis.get('market_size', '增长中')
            growth_rate = trend_analysis.get('growth_rate', '5-10%/年')
            job_demand = trend_analysis.get('job_demand', '高')
            avg_salary = trend_analysis.get('avg_salary', '具有竞争力')

            # 方法1：使用f-string替代.format()
            st.markdown(f"""
            <style>
            .metrics-table {{
                width: 100%;
                border-collapse: collapse;
                margin: 15px 0;
                font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            }}
            .metrics-table th {{
                background-color: #f0f7ff;
                padding: 10px;
                text-align: center;
                font-size: 14px;
                color: #475569;
                font-weight: normal;
                border: 1px solid #e2e8f0;
            }}
            .metrics-table td {{
                padding: 15px 10px;
                text-align: center;
                font-size: 18px;
                font-weight: bold;
                color: #1e3a8a;
                border: 1px solid #e2e8f0;
            }}
            </style>
            <table class="metrics-table">
                <tr>
                    <th>市场规模</th>
                    <th>增长率</th>
                    <th>岗位需求</th>
                    <th>平均薪资</th>
                </tr>
                <tr>
                    <td>{market_size}</td>
                    <td>{growth_rate}</td>
                    <td>{job_demand}</td>
                    <td>{avg_salary}</td>
                </tr>
            </table>
            """, unsafe_allow_html=True)

            # 或者方法2：将HTML/CSS与数据分离
            # html_template = """
            # <style>
            # .metrics-table {
            #     width: 100%;
            #     border-collapse: collapse;
            #     margin: 15px 0;
            #     font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            # }
            # .metrics-table th {
            #     background-color: #f0f7ff;
            #     padding: 10px;
            #     text-align: center;
            #     font-size: 14px;
            #     color: #475569;
            #     font-weight: normal;
            #     border: 1px solid #e2e8f0;
            # }
            # .metrics-table td {
            #     padding: 15px 10px;
            #     text-align: center;
            #     font-size: 18px;
            #     font-weight: bold;
            #     color: #1e3a8a;
            #     border: 1px solid #e2e8f0;
            # }
            # </style>
            # <table class="metrics-table">
            #     <tr>
            #         <th>市场规模</th>
            #         <th>增长率</th>
            #         <th>岗位需求</th>
            #         <th>平均薪资</th>
            #     </tr>
            #     <tr>
            #         <td>{0}</td>
            #         <td>{1}</td>
            #         <td>{2}</td>
            #         <td>{3}</td>
            #     </tr>
            # </table>
            # """
            # st.markdown(html_template.format(market_size, growth_rate, job_demand, avg_salary), unsafe_allow_html=True)
            
            # 显示行业阶段和竞争分析
            industry_stage = trend_analysis.get('industry_stage', {})
            if industry_stage:
                stage = industry_stage.get('stage', '')
                characteristics = industry_stage.get('characteristics', [])
                
                if stage:
                    st.markdown(f"""
                    <div style="background-color:#f8fafc; padding:15px; border-radius:10px; margin:20px 0; 
                                border:1px solid #e2e8f0;">
                        <h3 style="margin-top:0;">行业发展阶段: <span style="color:#6366f1;">{stage}</span></h3>
                        <ul style="margin-bottom:0;">
                            {' '.join([f'<li>{char}</li>' for char in characteristics])}
                        </ul>
                    </div>
                    """, unsafe_allow_html=True)
            
            # 创建选项卡布局，分别显示不同维度的分析
            tabs = st.tabs(["热门技能分析", "薪资与岗位趋势", "地区分布", "竞争格局", "行业前景"])
            
            # 选项卡1: 热门技能分析
            with tabs[0]:
                # 显示热门技能
                hot_skills = trend_analysis.get('hot_skills', [])
                emerging_skills = trend_analysis.get('emerging_skills', [])
                
                if hot_skills:
                    st.markdown("### 🔥 热门技能详情")
                    
                    # 创建更详细的热门技能卡片
                    for i, skill in enumerate(hot_skills):
                        skill_name = skill
                        skill_desc = ""
                        skill_importance = ""
                        skill_growth = ""
                        skill_applications = "各类项目和岗位"  # 默认值
                        skill_difficulty = "中等"  # 默认值
                        
                        if isinstance(skill, dict):
                            skill_name = skill.get('name', '')
                            skill_desc = skill.get('description', '')
                            skill_importance = skill.get('importance', '高')
                            skill_growth = skill.get('growth_trend', '上升')
                            skill_applications = skill.get('applications', '各类项目和岗位')
                            skill_difficulty = skill.get('learning_difficulty', '中等')
                        
                        # 根据重要性设置颜色
                        importance_color = "#3b82f6"  # 默认蓝色
                        if isinstance(skill_importance, str):
                            if '高' in skill_importance or 'high' in skill_importance.lower():
                                importance_color = "#ef4444"  # 红色
                            elif '中' in skill_importance or 'medium' in skill_importance.lower():
                                importance_color = "#f97316"  # 橙色
                        
                        # 修复: 使用st.markdown()代替unsafe_allow_html显示技能信息
                        with st.container():
                            col1, col2 = st.columns([3, 1])
                            with col1:
                                st.markdown(f"**{skill_name}**")
                                if skill_desc:
                                    st.write(skill_desc)
                            with col2:
                                st.markdown(f"重要性: **{skill_importance}**")
                                st.markdown(f"趋势: **{skill_growth}**")
                                
                            st.markdown(f"**应用场景:** {skill_applications}")
                            st.markdown(f"**学习难度:** {skill_difficulty}")
                            st.markdown("---")
                
                # 显示新兴技能
                if emerging_skills:
                    st.markdown("### 🚀 新兴技能")
                    
                    for skill in emerging_skills:
                        skill_name = skill
                        skill_desc = ""
                        
                        if isinstance(skill, dict):
                            skill_name = skill.get('name', '')
                            skill_desc = skill.get('description', '')
                        
                        st.markdown(f"""
                        <div style="background-color:#fef3c7; padding:10px 15px; border-radius:8px; 
                                    margin-bottom:10px; border-left:4px solid #f59e0b;">
                            <div style="font-weight:bold; font-size:16px; color:#92400e;">{skill_name}</div>
                            {f'<div style="color:#78350f; font-size:14px;">{skill_desc}</div>' if skill_desc else ''}
                        </div>
                        """, unsafe_allow_html=True)
                
                # 技能趋势变化图
                skill_trends = trend_analysis.get('skill_trends', {})
                if skill_trends and len(skill_trends) > 0:
                    st.markdown("### 📈 技能需求趋势")
                    
                    try:
                        import pandas as pd
                        import matplotlib.pyplot as plt
                        
                        # 创建趋势数据
                        trends_data = []
                        for skill, data in skill_trends.items():
                            if isinstance(data, dict) and 'trend_data' in data:
                                trends_data.append({
                                    '技能': skill,
                                    '前年': data['trend_data'].get('previous_year', 0),
                                    '去年': data['trend_data'].get('last_year', 0),
                                    '今年': data['trend_data'].get('current_year', 0),
                                    '预测': data['trend_data'].get('next_year', 0),
                                })
                        
                        if trends_data:
                            df = pd.DataFrame(trends_data)
                            df = df.set_index('技能')
                            
                            # 创建趋势图
                            fig, ax = plt.subplots(figsize=(10, 6))
                            df.plot(kind='line', marker='o', ax=ax)
                            plt.title('技能需求变化趋势')
                            plt.ylabel('需求指数')
                            plt.grid(True, linestyle='--', alpha=0.7)
                            st.pyplot(fig)
                    except Exception as e:
                        st.warning(f"无法显示趋势图: {str(e)}")
            
            # 选项卡2: 薪资与岗位趋势
            with tabs[1]:
                st.markdown("### 💰 薪资趋势分析")
                
                # 获取薪资趋势数据
                salary_trends = trend_analysis.get('salary_trends', {})
                
                if not salary_trends:
                    st.info("暂无详细薪资趋势数据。您可以重新分析或选择其他职位描述，获取更详细的行业薪资信息。")
                else:
                    # 显示薪资范围
                    entry_level = salary_trends.get('entry_level', '暂无数据')
                    mid_level = salary_trends.get('mid_level', '暂无数据')
                    senior_level = salary_trends.get('senior_level', '暂无数据')
                    
                    st.markdown(f"""
                    <div style="display:flex; justify-content:space-between; margin-bottom:20px;">
                        <div style="background-color:#f1f5f9; padding:15px; border-radius:8px; width:30%; 
                                    text-align:center; border-top:4px solid #9ca3af;">
                            <div style="font-size:14px; color:#4b5563;">初级</div>
                            <div style="font-size:20px; font-weight:bold; color:#111827;">{entry_level}</div>
                        </div>
                        <div style="background-color:#f1f5f9; padding:15px; border-radius:8px; width:30%; 
                                    text-align:center; border-top:4px solid #3b82f6;">
                            <div style="font-size:14px; color:#4b5563;">中级</div>
                            <div style="font-size:20px; font-weight:bold; color:#111827;">{mid_level}</div>
                        </div>
                        <div style="background-color:#f1f5f9; padding:15px; border-radius:8px; width:30%; 
                                    text-align:center; border-top:4px solid #f59e0b;">
                            <div style="font-size:14px; color:#4b5563;">高级</div>
                            <div style="font-size:20px; font-weight:bold; color:#111827;">{senior_level}</div>
                        </div>
                    </div>
                    """, unsafe_allow_html=True)
                
                # 薪资影响因素
                salary_factors = trend_analysis.get('salary_factors', [])
                if salary_factors:
                    st.markdown("#### 影响薪资的关键因素")
                    for factor in salary_factors:
                        factor_name = factor
                        factor_desc = ""
                        
                        if isinstance(factor, dict):
                            factor_name = factor.get('name', '')
                            factor_desc = factor.get('description', '')
                        
                        st.markdown(f"""
                        <div style="padding:10px; background-color:#f8fafc; border-radius:8px; 
                                    margin-bottom:10px; border-left:3px solid #64748b;">
                            <div style="font-weight:bold;">{factor_name}</div>
                            {f'<div style="font-size:14px; color:#4b5563;">{factor_desc}</div>' if factor_desc else ''}
                        </div>
                        """, unsafe_allow_html=True)
                
                # 岗位需求变化
                job_demand_trends = trend_analysis.get('job_demand_trends', {})
                
                if not job_demand_trends:
                    st.info("暂无详细岗位需求变化数据。该行业可能正在发展中，相关统计信息有限。")
                else:
                    st.markdown("### 📋 岗位需求变化")
                    
                    # 获取年度变化数据
                    yearly_data = job_demand_trends.get('yearly_change', {})
                    if yearly_data:
                        try:
                            import pandas as pd
                            
                            # 创建年度变化数据
                            years = list(yearly_data.keys())
                            values = list(yearly_data.values())
                            
                            # 计算同比增长率
                            growth_rates = []
                            for i in range(1, len(values)):
                                if values[i-1] > 0:
                                    growth_rate = (values[i] - values[i-1]) / values[i-1] * 100
                                    growth_rates.append(f"{growth_rate:.1f}%")
                                else:
                                    growth_rates.append("N/A")
                            
                            growth_rates.insert(0, "基准年")
                            
                            # 创建数据框
                            df = pd.DataFrame({
                                '年份': years,
                                '需求指数': values,
                                '同比增长': growth_rates
                            })
                            
                            st.dataframe(df, use_container_width=True)
                        except Exception as e:
                            st.warning(f"无法显示岗位需求数据: {str(e)}")
                    
                    # 招聘峰值期
                    peak_periods = job_demand_trends.get('peak_periods', [])
                    if peak_periods:
                        st.markdown("#### 招聘旺季")
                        st.info(', '.join(peak_periods))
            
            # 选项卡3: 地区分布
            with tabs[2]:
                # 使用display_city_cards函数显示城市卡片
                from region_cards import display_city_cards
                region_distribution = trend_analysis.get('region_distribution', {})
                display_city_cards(region_distribution)
            
            # 选项卡4: 竞争格局
            with tabs[3]:
                competition_analysis = trend_analysis.get('competition_analysis', {})
                if not competition_analysis:
                    st.info("暂无详细竞争格局数据。建议通过招聘平台和企业官网了解更多行业内主要企业情况。")
                else:
                    # 显示行业竞争格局
                    st.markdown("### 🏢 行业竞争格局")
                    
                    # 主要企业排行榜
                    major_companies = competition_analysis.get('major_companies', [])
                    unicorn_companies = competition_analysis.get('unicorn_companies', [])
                    
                    if major_companies:
                        st.markdown("#### 🏆 行业领军企业排行榜")
                        
                        # 创建CSS样式
                        st.markdown("""
                        <style>
                        .company-ranking {
                            margin-bottom: 30px;
                        }
                        .rank-card {
                            display: flex;
                            align-items: center;
                            padding: 12px 15px;
                            margin-bottom: 10px;
                            border-radius: 8px;
                            background-color: #f8fafc;
                            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                            transition: transform 0.2s;
                        }
                        .rank-card:hover {
                            transform: translateY(-2px);
                            box-shadow: 0 3px 5px rgba(0,0,0,0.15);
                        }
                        .rank-number {
                            width: 32px;
                            height: 32px;
                            border-radius: 50%;
                            background-color: #3b82f6;
                            color: white;
                            display: flex;
                            justify-content: center;
                            align-items: center;
                            font-weight: bold;
                            margin-right: 15px;
                            flex-shrink: 0;
                        }
                        .top-3 {
                            background-color: #f59e0b;
                        }
                        .company-logo {
                            width: 40px;
                            height: 40px;
                            border-radius: 5px;
                            margin-right: 15px;
                            object-fit: contain;
                            background-color: white;
                            flex-shrink: 0;
                            display: flex;
                            justify-content: center;
                            align-items: center;
                            font-weight: bold;
                            font-size: 16px;
                            color: white;
                        }
                        .company-info {
                            flex-grow: 1;
                        }
                        .company-name {
                            font-weight: bold;
                            font-size: 16px;
                            margin-bottom: 3px;
                        }
                        .company-desc {
                            font-size: 13px;
                            color: #64748b;
                        }
                        .company-type {
                            background-color: #e0e7ff;
                            color: #4338ca;
                            font-size: 12px;
                            padding: 3px 8px;
                            border-radius: 4px;
                            margin-left: 10px;
                        }
                        .company-value {
                            font-size: 13px;
                            color: #475569;
                            margin-top: 5px;
                        }
                        .unicorn-tag {
                            background-color: #fdf4ff;
                            color: #c026d3;
                            font-size: 12px;
                            padding: 3px 8px;
                            border-radius: 4px;
                            margin-left: 5px;
                        }
                        .company-initial {
                            width: 40px;
                            height: 40px;
                            border-radius: 5px;
                            display: flex;
                            justify-content: center;
                            align-items: center;
                            font-weight: bold;
                            font-size: 18px;
                            color: white;
                            margin-right: 15px;
                        }
                        </style>
                        """, unsafe_allow_html=True)
                        
                        # 显示企业排行榜
                        st.markdown('<div class="company-ranking">', unsafe_allow_html=True)
                        
                        # 生成随机颜色列表，用于企业首字母背景
                        colors = [
                            "#3b82f6", "#ef4444", "#10b981", "#f59e0b", "#8b5cf6", 
                            "#ec4899", "#06b6d4", "#f97316", "#6366f1", "#14b8a6"
                        ]
                        
                        for i, company in enumerate(major_companies[:10], 1):
                            name = company.get('name', f'企业{i}')
                            desc = company.get('description', '')
                            company_type = company.get('type', '')
                            logo_url = company.get('logo_url', '')
                            is_unicorn = company.get('is_unicorn', False)
                            market_value = company.get('market_value', '')
                            
                            # 生成企业首字母和背景色
                            initial = name[0].upper() if name else "?"
                            bg_color = colors[(i-1) % len(colors)]
                            
                            # 创建企业卡片 - 使用首字母显示替代Logo
                            unicorn_badge = '<span class="unicorn-tag">独角兽</span>' if is_unicorn else ''
                            value_text = f'<div class="company-value">{market_value}</div>' if market_value else ''
                            top_class = ' top-3' if i <= 3 else ''
                            
                            # 使用首字母代替Logo图片
                            st.markdown(f"""
                            <div class="rank-card">
                                <div class="rank-number{top_class}">{i}</div>
                                <div class="company-initial" style="background-color:{bg_color};">{initial}</div>
                                <div class="company-info">
                                    <div class="company-name">{name}{unicorn_badge}</div>
                                    <div class="company-desc">{desc}</div>
                                    {value_text}
                                </div>
                                <span class="company-type">{company_type}</span>
                            </div>
                            """, unsafe_allow_html=True)
                        
                        st.markdown('</div>', unsafe_allow_html=True)
                    
                    # 独角兽企业展示
                    if unicorn_companies:
                        st.markdown("#### 🦄 新兴独角兽企业")
                        
                        # 创建独角兽企业卡片布局
                        col1, col2 = st.columns(2)
                        
                        # 生成随机颜色列表，用于企业首字母背景
                        colors = [
                            "#c026d3", "#9333ea", "#4f46e5", "#0ea5e9", "#059669", 
                            "#ca8a04", "#dc2626", "#2563eb", "#c2410c", "#0f766e"
                        ]
                        
                        for i, company in enumerate(unicorn_companies):
                            name = company.get('name', f'独角兽企业{i+1}')
                            founded = company.get('founded_year', '')
                            valuation = company.get('valuation', '')
                            desc = company.get('description', '')
                            core_business = company.get('core_business', '')
                            logo_url = company.get('logo_url', '')
                            
                            # 生成企业首字母和背景色
                            initial = name[0].upper() if name else "?"
                            bg_color = colors[i % len(colors)]
                            
                            with col1 if i % 2 == 0 else col2:
                                st.markdown(f"""
                                <div style="background-color:#f8fafc; padding:15px; border-radius:10px; 
                                            margin-bottom:15px; border-left:4px solid #c026d3;">
                                    <div style="display:flex; align-items:center; margin-bottom:10px;">
                                        <div style="width:40px; height:40px; border-radius:5px; margin-right:10px; 
                                                    background-color:{bg_color}; color:white; display:flex; 
                                                    justify-content:center; align-items:center; font-weight:bold; font-size:18px;">
                                            {initial}
                                        </div>
                                        <div>
                                            <div style="font-weight:bold; font-size:16px;">{name}</div>
                                            <div style="font-size:12px; color:#64748b;">成立于 {founded}</div>
                                        </div>
                                    </div>
                                    <div style="background-color:#fdf4ff; color:#c026d3; display:inline-block; 
                                                padding:3px 8px; border-radius:4px; font-size:13px; margin-bottom:8px;">
                                        估值: {valuation}
                                    </div>
                                    <div style="font-size:14px; margin-top:5px;">
                                        <strong>核心业务:</strong> {core_business}
                                    </div>
                                    <div style="font-size:13px; color:#4b5563; margin-top:5px;">
                                        {desc}
                                    </div>
                                </div>
                                """, unsafe_allow_html=True)
        
        # 选项卡5: 行业前景
        with tabs[4]:
            # 显示行业前景
            outlook = trend_analysis.get('outlook', '')
            if not outlook or len(outlook) < 100:
                outlook = "系统未能提供足够详细的行业前景分析。建议通过专业行业报告或咨询行业专家获取更深入的见解。"
            
            st.markdown("### 🔮 行业整体前景")
            st.info(outlook)
            
            # 机遇与挑战
            opportunities = trend_analysis.get('opportunities', [])
            challenges = trend_analysis.get('challenges', [])
            
            # 如果数据缺失，提供默认内容
            if not opportunities:
                opportunities = ["行业正在快速发展，带来新的就业机会和专业化方向。", 
                                  "技术创新不断涌现，为从业者提供学习和成长的空间。", 
                                  "跨界融合趋势明显，复合型人才将更具竞争力。"]
            
            if not challenges:
                challenges = ["行业竞争日益激烈，要求从业者不断提升专业能力。", 
                            "技术更新迭代速度加快，需要持续学习适应变化。", 
                            "人才供给增长，可能导致入职门槛逐渐提高。"]
            
            col1, col2 = st.columns(2)
            
            with col1:
                st.markdown("### 🌟 行业机遇")
                for i, opportunity in enumerate(opportunities, 1):
                    st.success(f"{i}. {opportunity}")
            
            with col2:
                st.markdown("### 🧗 行业挑战")
                for i, challenge in enumerate(challenges, 1):
                    st.warning(f"{i}. {challenge}")
            
            # 未来发展预测
            future_predictions = trend_analysis.get('future_predictions', [])
            if future_predictions:
                st.markdown("### 🔭 未来3-5年发展预测")
                
                for i, prediction in enumerate(future_predictions, 1):
                    prediction_text = prediction
                    prediction_year = ""
                    
                    if isinstance(prediction, dict):
                        prediction_text = prediction.get('content', '')
                        prediction_year = prediction.get('year', '')
                    
                    st.markdown(f"""
                    <div style="background-color:#f0f9ff; padding:15px; border-radius:8px; 
                                margin-bottom:15px; border-left:4px solid #0ea5e9;">
                        <div style="font-weight:bold;">
                            预测 {i} {f'({prediction_year})' if prediction_year else ''}
                        </div>
                        <div style="line-height:1.5;">{prediction_text}</div>
                    </div>
                    """, unsafe_allow_html=True)
    
    with tab3:
        # 显示职业发展路径
        st.subheader("职业发展路径")
        
        career_paths = results.get('career_paths', [])
        
        if career_paths:
            for i, path in enumerate(career_paths, 1):
                # 创建可折叠区域
                with st.expander(f"路径 {i}: {path.get('name', '职业发展路径')}", expanded=(i==1)):
                    positions = path.get('positions', [])
                    
                    # 显示职位发展时间轴
                    if positions:
                        st.markdown("#### 职业发展时间轴")
                        
                        # 创建时间轴HTML
                        timeline_html = """
                        <div style="margin:20px 0; position:relative;">
                            <div style="position:absolute; top:15px; left:0; right:0; height:4px; background-color:#ddd; z-index:1;"></div>
                        """
                        
                        for j, position in enumerate(positions):
                            position_title = position.get('title', f"职位 {j+1}")
                            is_current = position.get('is_current', False)
                            time_required = position.get('time_required', '')
                            
                            # 计算位置百分比
                            position_percent = (j / (len(positions) - 1) * 100) if len(positions) > 1 else 50
                            
                            # 当前职位使用绿色，其他职位使用蓝色
                            background_color = "#4CAF50" if is_current else "#2196F3"
                            
                            timeline_html += f"""
                            <div style="position:relative; z-index:2; display:inline-block; width:25px; height:25px; 
                                       background-color:{background_color}; border-radius:50%; 
                                       left:calc({position_percent}% - 12px); 
                                       margin-top:5px;">
                            </div>
                            <div style="position:absolute; left:{position_percent}%; transform:translateX(-50%); 
                                       margin-top:35px; text-align:center; width:120px;">
                                <div style="font-weight:bold; font-size:14px;">{position_title}</div>
                                <div style="font-size:12px; color:#666;">{time_required}</div>
                            </div>
                            """
                        
                        timeline_html += """
                        </div>
                        <div style="height:80px;"></div>
                        """
                        
                        st.markdown(timeline_html, unsafe_allow_html=True)
                    
                    # 显示详细职位信息
                    if positions:
                        for j, position in enumerate(positions):
                            position_title = position.get('title', f"职位 {j+1}")
                            required_skills = position.get('required_skills', [])
                            
                            st.markdown(f"#### {position_title}")
                            
                            if required_skills:
                                st.markdown("##### 所需技能:")
                                
                                # 显示技能标签
                                skills_html = ""
                                for skill in required_skills:
                                    skills_html += f"""
                                    <div style="display:inline-block; margin:5px; padding:6px 12px; 
                                    background-color:#e3f2fd; border-radius:15px; font-size:12px;">
                                        {skill}
                                    </div>
                                    """
                                
                                st.markdown(f"""
                                <div style="margin:10px 0;">
                                    {skills_html}
                                </div>
                                """, unsafe_allow_html=True)
                    
                    # 显示优势和挑战
                    col1, col2 = st.columns(2)
                    
                    with col1:
                        advantages = path.get('advantages', [])
                        if advantages:
                            st.markdown("#### 优势")
                            for adv in advantages:
                                st.markdown(f"""
                                <div style="background-color:#e8f5e9; padding:10px; border-radius:5px; 
                                            margin-bottom:10px; border-left:3px solid #4CAF50;">
                                    ✅ {adv}
                                </div>
                                """, unsafe_allow_html=True)
                    
                    with col2:
                        challenges = path.get('challenges', [])
                        if challenges:
                            st.markdown("#### 挑战")
                            for challenge in challenges:
                                st.markdown(f"""
                                <div style="background-color:#fff8e1; padding:10px; border-radius:5px; 
                                            margin-bottom:10px; border-left:3px solid #FFC107;">
                                    ⚠️ {challenge}
                                </div>
                                """, unsafe_allow_html=True)
    
    with tab4:
        # 显示学习计划
        st.subheader("学习计划")
        
        learning_plan = results.get('learning_plan', {})
        
        if learning_plan:
            # 显示计划概要
            timeline_months = learning_plan.get('timeline_months', 3)
            st.markdown(f"#### {timeline_months}个月学习计划")
            
            # 获取技能计划
            skills_plan = learning_plan.get('skills_plan', {})
            if isinstance(skills_plan, dict) and 'skills' in skills_plan:
                skills = skills_plan['skills']
                
                if skills:
                    # 创建技能表格
                    st.markdown("#### 技能学习分配")
                    
                    skill_data = []
                    for skill in skills:
                        skill_data.append({
                            "技能名称": skill.get('skill_name', ''),
                            "优先级": skill.get('priority', ''),
                            "分配时间(月)": skill.get('months_allocated', 0),
                            "当前水平": skill.get('current_level', 0),
                            "目标水平": skill.get('target_level', 0)
                        })
                    
                    if skill_data:
                        import pandas as pd
                        skill_df = pd.DataFrame(skill_data)
                        st.dataframe(skill_df, use_container_width=True, hide_index=True)
                    
                    # 显示每周时间安排
                    weekly_schedule = learning_plan.get('weekly_schedule', {})
                    if weekly_schedule:
                        st.markdown("#### 每周学习时间安排")
                        
                        # 创建每周时间表可视化
                        days = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"]
                        schedule_data = {}
                        
                        for skill, data in weekly_schedule.items():
                            daily_hours = data.get('daily_distribution', [0] * 7)
                            schedule_data[skill] = daily_hours
                        
                        if schedule_data:
                            try:
                                import pandas as pd
                                
                                # 转换为DataFrame
                                schedule_df = pd.DataFrame(schedule_data, index=days)
                                
                                # 创建热力图
                                import matplotlib.pyplot as plt
                                import seaborn as sns
                                
                                fig, ax = plt.subplots(figsize=(10, 6))
                                sns.heatmap(schedule_df, annot=True, cmap="YlGnBu", fmt="d", cbar_kws={'label': '小时'})
                                plt.title("每周学习时间分配")
                                plt.ylabel("星期")
                                plt.xlabel("技能")
                                
                                st.pyplot(fig)
                                
                            except Exception as e:
                                st.error(f"创建学习时间表时出错: {str(e)}")
                                st.write(schedule_data)
                    
                    # 显示学习资源推荐
                    resources = learning_plan.get('resources', {})
                    if resources:
                        st.markdown("#### 学习资源推荐")
                        
                        # 为每个技能显示资源
                        for skill, skill_resources in resources.items():
                            with st.expander(f"{skill}学习资源"):
                                # 显示课程
                                courses = skill_resources.get('courses', [])
                                if courses:
                                    st.markdown("##### 推荐课程")
                                    for course in courses:
                                        course_name = course.get('name', '')
                                        platform = course.get('platform', '')
                                        
                                        st.markdown(f"""
                                        <div style="background-color:#f5f5f5; padding:10px; border-radius:5px; margin-bottom:5px;">
                                            <b>📚 {course_name}</b> <span style="color:#666;">({platform})</span>
                                        </div>
                                        """, unsafe_allow_html=True)
                                
                                # 显示项目
                                projects = skill_resources.get('projects', [])
                                if projects:
                                    st.markdown("##### 实战项目")
                                    for project in projects:
                                        project_name = project.get('name', '')
                                        description = project.get('description', '')
                                        
                                        st.markdown(f"""
                                        <div style="background-color:#e8f5e9; padding:10px; border-radius:5px; margin-bottom:5px;">
                                            <b>💻 {project_name}</b>
                                            <p style="margin:5px 0 0 0; font-size:14px; color:#666;">{description}</p>
                                        </div>
                                        """, unsafe_allow_html=True)
                    
                    # 显示学习里程碑
                    milestones = learning_plan.get('milestones', [])
                    if milestones:
                        st.markdown("#### 学习里程碑")
                        
                        for milestone in milestones:
                            date = milestone.get('date', '')
                            name = milestone.get('name', '')
                            description = milestone.get('description', '')
                            
                            st.markdown(f"""
                            <div style="background-color:#e3f2fd; padding:15px; border-radius:5px; margin-bottom:15px;">
                                <div style="font-weight:bold; font-size:16px;">📅 {name} ({date})</div>
                                <p style="margin:5px 0; color:#333;">{description}</p>
                            </div>
                            """, unsafe_allow_html=True)

def skill_diagnosis_page():
    """技能诊断页面"""
    st.title("技能诊断")
    
    # 设置当前页面标识，用于下拉框的唯一键
    st.session_state['_current_page'] = "skill_diagnosis"
    
    # 检查是否已有配置信息
    if not (st.session_state.get('resume_text') and st.session_state.get('job_desc')):
        st.warning("⚠️ 请先在「个人配置」中设置您的简历和目标职位信息")
        st.button("前往个人配置", on_click=lambda: st._set_query_params(page="个人配置"))
        return
    
    # 检查是否已有分析结果
    if 'results' not in st.session_state or not st.session_state.get('results', {}).get('match_analysis'):
        # 使用统一的个人信息预览组件
        show_profile_preview(expanded=False)
        
        # 提供直接分析按钮
        if st.button("👨‍💻 开始技能匹配分析", help="使用个人配置中的简历和职位信息进行分析"):
            with st.spinner("正在分析技能匹配度..."):
                try:
                    # 从session获取信息
                    resume = st.session_state.get('resume_text', '')
                    job = st.session_state.get('job_desc', '')
                    
                    # 进行分析
                    user_skills, job_skills, match_analysis = system.skill_diagnosis.analyze_resume_and_job_together(
                        resume, job
                    )
                    
                    # 临时保存结果，但不覆盖完整分析的结果
                    if 'results' not in st.session_state:
                        st.session_state.results = {}
                    
                    st.session_state.results['match_analysis'] = match_analysis
                    st.session_state.results['user_skills'] = user_skills
                    st.session_state.results['job_skills'] = job_skills
                    
                    # 显示详细匹配结果
                    if match_analysis and 'overall_match' in match_analysis:
                        overall_match = match_analysis['overall_match']
                        
                        # 根据匹配度设置颜色和图标
                        if overall_match >= 80:
                            match_color = "#4CAF50"  # 绿色
                            match_icon = "🌟"
                            match_text = "非常匹配"
                        elif overall_match >= 60:
                            match_color = "#FF9800"  # 橙色
                            match_icon = "⭐"
                            match_text = "良好匹配"
                        else:
                            match_color = "#F44336"  # 红色
                            match_icon = "⚠️"
                            match_text = "需要提升"
                        
                        # 1. 显示总体匹配度卡片
                        st.markdown(f"""
                        <div style="display:flex; align-items:center; padding:15px; background-color:#f8f9fa; 
                                    border-radius:10px; margin-bottom:20px;">
                            <div style="font-size:48px; font-weight:bold; color:{match_color}; margin-right:20px;">
                                {overall_match}%
                            </div>
                            <div>
                                <div style="font-size:20px;">{match_icon} <b>{match_text}</b></div>
                                <div style="color:#666;">总体职位匹配度</div>
                            </div>
                        </div>
                        """, unsafe_allow_html=True)
                        
                        # 2. 创建两列布局
                        col1, col2 = st.columns([3, 2])
                        
                        with col1:
                            # 显示技能雷达图
                            if match_analysis.get('match_analysis'):
                                try:
                                    # 提取技能数据
                                    match_details = match_analysis['match_analysis']
                                    
                                    # 准备雷达图数据
                                    import matplotlib.pyplot as plt
                                    import numpy as np
                                    
                                    # 提取前5个关键技能
                                    skills = list(match_details.keys())[:5]
                                    if skills:
                                        user_levels = [match_details[s].get('user_level', 0) for s in skills]
                                        job_levels = [match_details[s].get('job_requirement', 0) for s in skills]
                                        
                                        # 创建雷达图
                                        fig = plt.figure(figsize=(8, 6))
                                        ax = fig.add_subplot(111, polar=True)
                                        
                                        # 计算角度
                                        angles = np.linspace(0, 2*np.pi, len(skills), endpoint=False).tolist()
                                        
                                        # 闭合图形
                                        skills = skills + [skills[0]]
                                        angles = angles + [angles[0]]
                                        user_levels = user_levels + [user_levels[0]]
                                        job_levels = job_levels + [job_levels[0]]
                                        
                                        # 绘制用户技能水平
                                        ax.plot(angles, user_levels, 'o-', linewidth=2, label='您的水平', color='#4CAF50')
                                        ax.fill(angles, user_levels, alpha=0.25, color='#4CAF50')
                                        
                                        # 绘制职位要求水平
                                        ax.plot(angles, job_levels, 'o-', linewidth=2, label='职位要求', color='#2196F3')
                                        ax.fill(angles, job_levels, alpha=0.1, color='#2196F3')
                                        
                                        # 设置刻度和网格
                                        ax.set_xticks(angles[:-1])
                                        ax.set_xticklabels(skills[:-1], fontsize=10, fontweight='bold')
                                        ax.set_ylim(0, 100)
                                        
                                        # 添加图例
                                        plt.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1))
                                        
                                        st.pyplot(fig)
                                    else:
                                        st.info("没有足够的技能数据生成雷达图")
                                except Exception as e:
                                    st.error(f"生成雷达图时出错: {str(e)}")
                        
                        with col2:
                            # 3. 显示竞争力分析
                            if 'competitiveness_analysis' in match_analysis:
                                st.markdown("### 就业竞争力分析")
                                st.markdown(f"""
                                <div style="background-color:#f0f7ff; padding:15px; border-radius:10px; 
                                            border-left:5px solid {match_color}; margin-bottom:20px;">
                                    {match_analysis['competitiveness_analysis']}
                                </div>
                                """, unsafe_allow_html=True)
                        
                        # 4. 显示技能差距详情表格
                        if match_analysis.get('match_analysis'):
                            st.markdown("### 技能差距详情")
                            
                            # 创建表格数据
                            match_data = []
                            for skill, data in match_analysis['match_analysis'].items():
                                if isinstance(data, dict):
                                    match_data.append({
                                        "技能": skill,
                                        "您的水平": data.get('user_level', 0),
                                        "职位要求": data.get('job_requirement', 0),
                                        "差距": data.get('gap', 0),
                                        "匹配度": f"{data.get('match_percentage', 0):.1f}%"
                                    })
                            
                            if match_data:
                                # 转换为DataFrame并显示
                                import pandas as pd
                                match_df = pd.DataFrame(match_data)
                                st.dataframe(match_df, use_container_width=True, hide_index=True)
                        
                        # 5. 显示提升建议
                        if 'improvement_suggestions' in match_analysis:
                            st.markdown("### 提升建议")
                            
                            suggestions = match_analysis['improvement_suggestions']
                            if isinstance(suggestions, list) and suggestions:
                                for i, suggestion in enumerate(suggestions, 1):
                                    st.markdown(f"""
                                    <div style="background-color:#f0f7ff; padding:10px; border-radius:5px; 
                                                margin-bottom:10px; border-left:3px solid #3b82f6;">
                                        <strong>{i}.</strong> {suggestion}
                                    </div>
                                    """, unsafe_allow_html=True)
                            elif isinstance(suggestions, str):
                                st.info(suggestions)
                        
                        # 6. 显示职业前景
                        if 'career_prospects' in match_analysis:
                            st.markdown("### 职业前景分析")
                            st.markdown(f"""
                            <div style="background-color:#f0fff4; padding:15px; border-radius:10px; 
                                        border-left:5px solid #4CAF50; margin:15px 0;">
                                {match_analysis['career_prospects']}
                            </div>
                            """, unsafe_allow_html=True)
                    
                except Exception as e:
                    st.error(f"分析过程中发生错误: {str(e)}")
                    st.error(traceback.format_exc())
    else:
        # 从结果中获取技能匹配部分
        results = st.session_state.results
        
        # 显示匹配分析内容
        if 'match_analysis' in results:
            match_analysis = results['match_analysis']
            
            # 显示总体匹配度和详细分析
            if 'overall_match' in match_analysis:
                overall_match = match_analysis['overall_match']
                
                # 根据匹配度设置颜色和图标
                if overall_match >= 80:
                    match_color = "#4CAF50"  # 绿色
                    match_icon = "🌟"
                    match_text = "非常匹配"
                elif overall_match >= 60:
                    match_color = "#FF9800"  # 橙色
                    match_icon = "⭐"
                    match_text = "良好匹配"
                else:
                    match_color = "#F44336"  # 红色
                    match_icon = "⚠️"
                    match_text = "需要提升"
                
                # 显示总体匹配度卡片
                st.markdown(f"""
                <div style="display:flex; align-items:center; padding:15px; background-color:#f8f9fa; 
                            border-radius:10px; margin-bottom:20px;">
                    <div style="font-size:48px; font-weight:bold; color:{match_color}; margin-right:20px;">
                        {overall_match}%
                    </div>
                    <div>
                        <div style="font-size:20px;">{match_icon} <b>{match_text}</b></div>
                        <div style="color:#666;">总体职位匹配度</div>
                    </div>
                </div>
                """, unsafe_allow_html=True)
                
                # 创建两列布局
                col1, col2 = st.columns([3, 2])
                
                with col1:
                    # 显示技能雷达图
                    if match_analysis.get('match_analysis'):
                        try:
                            # 提取技能数据
                            match_details = match_analysis['match_analysis']
                            
                            # 准备雷达图数据
                            import matplotlib.pyplot as plt
                            import numpy as np
                            
                            # 提取前5个关键技能
                            skills = list(match_details.keys())[:5]
                            if skills:
                                user_levels = [match_details[s].get('user_level', 0) for s in skills]
                                job_levels = [match_details[s].get('job_requirement', 0) for s in skills]
                                
                                # 创建雷达图
                                fig = plt.figure(figsize=(8, 6))
                                ax = fig.add_subplot(111, polar=True)
                                
                                # 计算角度
                                angles = np.linspace(0, 2*np.pi, len(skills), endpoint=False).tolist()
                                
                                # 闭合图形
                                skills = skills + [skills[0]]
                                angles = angles + [angles[0]]
                                user_levels = user_levels + [user_levels[0]]
                                job_levels = job_levels + [job_levels[0]]
                                
                                # 绘制用户技能水平
                                ax.plot(angles, user_levels, 'o-', linewidth=2, label='您的水平', color='#4CAF50')
                                ax.fill(angles, user_levels, alpha=0.25, color='#4CAF50')
                                
                                # 绘制职位要求水平
                                ax.plot(angles, job_levels, 'o-', linewidth=2, label='职位要求', color='#2196F3')
                                ax.fill(angles, job_levels, alpha=0.1, color='#2196F3')
                                
                                # 设置刻度和网格
                                ax.set_xticks(angles[:-1])
                                ax.set_xticklabels(skills[:-1], fontsize=10, fontweight='bold')
                                ax.set_ylim(0, 100)
                                
                                # 添加图例
                                plt.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1))
                                
                                st.pyplot(fig)
                            else:
                                st.info("没有足够的技能数据生成雷达图")
                        except Exception as e:
                            st.error(f"生成雷达图时出错: {str(e)}")
                
                with col2:
                    # 显示竞争力分析
                    if 'competitiveness_analysis' in match_analysis:
                        st.markdown("### 就业竞争力分析")
                        st.markdown(f"""
                        <div style="background-color:#f0f7ff; padding:15px; border-radius:10px; 
                                    border-left:5px solid {match_color}; margin-bottom:20px;">
                            {match_analysis['competitiveness_analysis']}
                        </div>
                        """, unsafe_allow_html=True)
                    
                    # 显示技能差距详情表格
                    if match_analysis.get('match_analysis'):
                        st.markdown("### 技能差距详情")
                        
                        # 创建表格数据
                        match_data = []
                        for skill, data in match_analysis['match_analysis'].items():
                            if isinstance(data, dict):
                                match_data.append({
                                    "技能": skill,
                                    "您的水平": data.get('user_level', 0),
                                    "职位要求": data.get('job_requirement', 0),
                                    "差距": data.get('gap', 0),
                                    "匹配度": f"{data.get('match_percentage', 0):.1f}%"
                                })
                        
                        if match_data:
                            # 转换为DataFrame并显示
                            import pandas as pd
                            match_df = pd.DataFrame(match_data)
                            st.dataframe(match_df, use_container_width=True, hide_index=True)
                    
                    # 显示提升建议
                    if 'improvement_suggestions' in match_analysis:
                        st.markdown("### 提升建议")
                        
                        suggestions = match_analysis['improvement_suggestions']
                        if isinstance(suggestions, list) and suggestions:
                            for i, suggestion in enumerate(suggestions, 1):
                                st.markdown(f"""
                                <div style="background-color:#f0f7ff; padding:10px; border-radius:5px; 
                                            margin-bottom:10px; border-left:3px solid #3b82f6;">
                                    <strong>{i}.</strong> {suggestion}
                                </div>
                                """, unsafe_allow_html=True)
                        elif isinstance(suggestions, str):
                            st.info(suggestions)
                    
                    # 显示职业前景
                    if 'career_prospects' in match_analysis:
                        st.markdown("### 职业前景分析")
                        st.markdown(f"""
                        <div style="background-color:#f0fff4; padding:15px; border-radius:10px; 
                                    border-left:5px solid #4CAF50; margin:15px 0;">
                            {match_analysis['career_prospects']}
                        </div>
                        """, unsafe_allow_html=True)

def display_trend_analysis_results(trend_analysis):
    """显示行业趋势分析结果
    
    Args:
        trend_analysis (dict): 趋势分析结果数据
    """
    if trend_analysis:
        st.success("行业趋势分析完成！")
        
        # 显示行业名称和概要
        industry = trend_analysis.get('industry', '信息技术')
        # 获取行业描述
        industry_description = trend_analysis.get('description', '')
        
        st.markdown(f"""
        <div style="background-color:#f0f7ff; padding:20px; border-radius:10px; margin-bottom:25px;">
            <h2 style="margin-top:0; color:#1e3a8a;">{industry}行业分析</h2>
            <p style="font-size:16px; color:#4b5563;">{industry_description}</p>
        </div>
        """, unsafe_allow_html=True)
        
        # 创建行业概览表格
        st.subheader("📊 行业发展概览")
        
        # 从分析结果中获取关键指标
        market_size = trend_analysis.get('market_size', '增长中')
        growth_rate = trend_analysis.get('growth_rate', '5-10%/年')
        job_demand = trend_analysis.get('job_demand', '高')
        avg_salary = trend_analysis.get('avg_salary', '具有竞争力')
        
        # 使用HTML创建统一样式的表格
        st.markdown(f"""
        <style>
        .metrics-table {{
            width: 100%;
            border-collapse: collapse;
            margin: 15px 0;
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
        }}
        .metrics-table th {{
            background-color: #f0f7ff;
            padding: 10px;
            text-align: center;
            font-size: 14px;
            color: #475569;
            font-weight: normal;
            border: 1px solid #e2e8f0;
        }}
        .metrics-table td {{
            padding: 15px 10px;
            text-align: center;
            font-size: 18px;
            font-weight: bold;
            color: #1e3a8a;
            border: 1px solid #e2e8f0;
        }}
        </style>
        <table class="metrics-table">
            <tr>
                <th>市场规模</th>
                <th>增长率</th>
                <th>岗位需求</th>
                <th>平均薪资</th>
            </tr>
            <tr>
                <td>{market_size}</td>
                <td>{growth_rate}</td>
                <td>{job_demand}</td>
                <td>{avg_salary}</td>
            </tr>
        </table>
        """, unsafe_allow_html=True)
        
        # 显示行业阶段和竞争分析
        industry_stage = trend_analysis.get('industry_stage', {})
        if industry_stage:
            stage = industry_stage.get('stage', '')
            characteristics = industry_stage.get('characteristics', [])
            
            if stage:
                st.markdown(f"""
                <div style="background-color:#f8fafc; padding:15px; border-radius:10px; margin:20px 0; 
                            border:1px solid #e2e8f0;">
                    <h3 style="margin-top:0;">行业发展阶段: <span style="color:#6366f1;">{stage}</span></h3>
                    <ul style="margin-bottom:0;">
                        {' '.join([f'<li>{char}</li>' for char in characteristics])}
                    </ul>
                </div>
                """, unsafe_allow_html=True)
        
        # 创建选项卡布局，分别显示不同维度的分析
        tabs = st.tabs(["热门技能分析", "薪资与岗位趋势", "地区分布", "竞争格局", "行业前景"])
        
        # 选项卡1: 热门技能分析
        with tabs[0]:
            # 显示热门技能
            hot_skills = trend_analysis.get('hot_skills', [])
            emerging_skills = trend_analysis.get('emerging_skills', [])
            
            if hot_skills:
                st.markdown("### 🔥 热门技能详情")
                
                # 创建更详细的热门技能卡片
                for i, skill in enumerate(hot_skills):
                    skill_name = skill
                    skill_desc = ""
                    skill_importance = ""
                    skill_growth = ""
                    skill_applications = "各类项目和岗位"  # 默认值
                    skill_difficulty = "中等"  # 默认值
                    
                    if isinstance(skill, dict):
                        skill_name = skill.get('name', '')
                        skill_desc = skill.get('description', '')
                        skill_importance = skill.get('importance', '高')
                        skill_growth = skill.get('growth_trend', '上升')
                        skill_applications = skill.get('applications', '各类项目和岗位')
                        skill_difficulty = skill.get('learning_difficulty', '中等')
                    
                    # 根据重要性设置颜色
                    importance_color = "#3b82f6"  # 默认蓝色
                    if isinstance(skill_importance, str):
                        if '高' in skill_importance or 'high' in skill_importance.lower():
                            importance_color = "#ef4444"  # 红色
                        elif '中' in skill_importance or 'medium' in skill_importance.lower():
                            importance_color = "#f97316"  # 橙色
                    
                    # 使用Streamlit原生组件而不是复杂HTML
                    with st.container():
                        col1, col2 = st.columns([3, 1])
                        with col1:
                            st.markdown(f"**{skill_name}**")
                            if skill_desc:
                                st.write(skill_desc)
                        with col2:
                            st.markdown(f"重要性: **{skill_importance}**")
                            st.markdown(f"趋势: **{skill_growth}**")
                            
                        st.markdown(f"**应用场景:** {skill_applications}")
                        st.markdown(f"**学习难度:** {skill_difficulty}")
                        st.markdown("---")
            
            # 显示新兴技能
            if emerging_skills:
                st.markdown("### 🚀 新兴技能")
                
                for skill in emerging_skills:
                    skill_name = skill
                    skill_desc = ""
                    
                    if isinstance(skill, dict):
                        skill_name = skill.get('name', '')
                        skill_desc = skill.get('description', '')
                    
                    st.markdown(f"""
                    <div style="background-color:#fef3c7; padding:10px 15px; border-radius:8px; 
                                margin-bottom:10px; border-left:4px solid #f59e0b;">
                        <div style="font-weight:bold; font-size:16px; color:#92400e;">{skill_name}</div>
                        {f'<div style="color:#78350f; font-size:14px;">{skill_desc}</div>' if skill_desc else ''}
                    </div>
                    """, unsafe_allow_html=True)
        
        # 选项卡2: 薪资与岗位趋势
        with tabs[1]:
            st.markdown("### 💰 薪资趋势分析")
            
            # 获取薪资趋势数据
            salary_trends = trend_analysis.get('salary_trends', {})
            
            if not salary_trends:
                st.info("暂无详细薪资趋势数据。您可以重新分析或选择其他职位描述，获取更详细的行业薪资信息。")
            else:
                # 显示薪资范围
                entry_level = salary_trends.get('entry_level', '暂无数据')
                mid_level = salary_trends.get('mid_level', '暂无数据')
                senior_level = salary_trends.get('senior_level', '暂无数据')
                
                col1, col2, col3 = st.columns(3)
                with col1:
                    st.metric("初级薪资", entry_level)
                with col2:
                    st.metric("中级薪资", mid_level)
                with col3:
                    st.metric("高级薪资", senior_level)
            
            # 薪资影响因素
            salary_factors = trend_analysis.get('salary_factors', [])
            if salary_factors:
                st.markdown("#### 影响薪资的关键因素")
                for factor in salary_factors:
                    factor_name = factor
                    factor_desc = ""
                    
                    if isinstance(factor, dict):
                        factor_name = factor.get('name', '')
                        factor_desc = factor.get('description', '')
                    
                    st.markdown(f"""
                    <div style="padding:10px; background-color:#f8fafc; border-radius:8px; 
                                margin-bottom:10px; border-left:3px solid #64748b;">
                        <div style="font-weight:bold;">{factor_name}</div>
                        {f'<div style="font-size:14px; color:#4b5563;">{factor_desc}</div>' if factor_desc else ''}
                    </div>
                    """, unsafe_allow_html=True)
            
            # 岗位需求变化
            job_demand_trends = trend_analysis.get('job_demand_trends', {})
            if not job_demand_trends:
                st.info("暂无详细岗位需求变化数据。该行业可能正在发展中，相关统计信息有限。")
        
        # 选项卡3: 地区分布
        with tabs[2]:
            region_distribution = trend_analysis.get('region_distribution', {})
            if not region_distribution or not region_distribution.get('top_cities'):
                st.info("暂无详细地区分布数据。您可以通过职位搜索网站了解不同地区的职位分布情况。")
            else:
                # 显示现有的地区分布数据
                # 地区分布概览
                st.markdown("### 🗺️ 全国职位地区分布")
                
                # 显示城市分布数据
                city_data = []
                for city in region_distribution.get('top_cities', []):
                    if city.get('name'):
                        city_data.append({
                            "城市": city.get('name', ''),
                            "岗位占比": city.get('percentage', 'N/A'),
                            "主导行业": ", ".join(city.get('dominant_industries', [])) if isinstance(city.get('dominant_industries'), list) else "多元化",
                            "平均薪资": city.get('avg_salary', 'N/A')
                        })
                
                if city_data:
                    import pandas as pd
                    st.dataframe(pd.DataFrame(city_data), use_container_width=True, hide_index=True)
                
                # 区域产业结构信息
                regional_features = region_distribution.get('regional_features', [])
                if regional_features:
                    st.markdown("### 🏭 区域产业结构")
                    for feature in regional_features:
                        region_name = feature.get('region', '')
                        if region_name:
                            with st.expander(f"{region_name}区域", expanded=False):
                                st.write(feature.get('characteristics', ''))
                                
                                industrial_focus = feature.get('industrial_focus', [])
                                if industrial_focus:
                                    st.markdown("**重点产业:**")
                                    st.write(", ".join(industrial_focus))
        
        # 选项卡4: 竞争格局
        with tabs[3]:
            competition_analysis = trend_analysis.get('competition_analysis', {})
            if not competition_analysis:
                st.info("暂无详细竞争格局数据。建议通过招聘平台和企业官网了解更多行业内主要企业情况。")
            else:
                # 显示行业竞争格局
                st.markdown("### 🏢 行业竞争格局")
                
                # 主要企业排行榜
                major_companies = competition_analysis.get('major_companies', [])
                unicorn_companies = competition_analysis.get('unicorn_companies', [])
                
                if major_companies:
                    st.markdown("#### 🏆 行业领军企业排行榜")
                    
                    # 创建CSS样式
                    st.markdown("""
                    <style>
                    .company-ranking {
                        margin-bottom: 30px;
                    }
                    .rank-card {
                        display: flex;
                        align-items: center;
                        padding: 12px 15px;
                        margin-bottom: 10px;
                        border-radius: 8px;
                        background-color: #f8fafc;
                        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                        transition: transform 0.2s;
                    }
                    .rank-card:hover {
                        transform: translateY(-2px);
                        box-shadow: 0 3px 5px rgba(0,0,0,0.15);
                    }
                    .rank-number {
                        width: 32px;
                        height: 32px;
                        border-radius: 50%;
                        background-color: #3b82f6;
                        color: white;
                        display: flex;
                        justify-content: center;
                        align-items: center;
                        font-weight: bold;
                        margin-right: 15px;
                        flex-shrink: 0;
                    }
                    .top-3 {
                        background-color: #f59e0b;
                    }
                    .company-logo {
                        width: 40px;
                        height: 40px;
                        border-radius: 5px;
                        margin-right: 15px;
                        object-fit: contain;
                        background-color: white;
                        flex-shrink: 0;
                        display: flex;
                        justify-content: center;
                        align-items: center;
                        font-weight: bold;
                        font-size: 16px;
                        color: white;
                    }
                    .company-info {
                        flex-grow: 1;
                    }
                    .company-name {
                        font-weight: bold;
                        font-size: 16px;
                        margin-bottom: 3px;
                    }
                    .company-desc {
                        font-size: 13px;
                        color: #64748b;
                    }
                    .company-type {
                        background-color: #e0e7ff;
                        color: #4338ca;
                        font-size: 12px;
                        padding: 3px 8px;
                        border-radius: 4px;
                        margin-left: 10px;
                    }
                    .company-value {
                        font-size: 13px;
                        color: #475569;
                        margin-top: 5px;
                    }
                    .unicorn-tag {
                        background-color: #fdf4ff;
                        color: #c026d3;
                        font-size: 12px;
                        padding: 3px 8px;
                        border-radius: 4px;
                        margin-left: 5px;
                    }
                    .company-initial {
                        width: 40px;
                        height: 40px;
                        border-radius: 5px;
                        display: flex;
                        justify-content: center;
                        align-items: center;
                        font-weight: bold;
                        font-size: 18px;
                        color: white;
                        margin-right: 15px;
                    }
                    </style>
                    """, unsafe_allow_html=True)
                        
                    # 显示企业排行榜
                    st.markdown('<div class="company-ranking">', unsafe_allow_html=True)
                    
                    # 生成随机颜色列表，用于企业首字母背景
                    colors = [
                        "#3b82f6", "#ef4444", "#10b981", "#f59e0b", "#8b5cf6", 
                        "#ec4899", "#06b6d4", "#f97316", "#6366f1", "#14b8a6"
                    ]
                    
                    for i, company in enumerate(major_companies[:10], 1):
                        name = company.get('name', f'企业{i}')
                        desc = company.get('description', '')
                        company_type = company.get('type', '')
                        logo_url = company.get('logo_url', '')
                        is_unicorn = company.get('is_unicorn', False)
                        market_value = company.get('market_value', '')
                        
                        # 生成企业首字母和背景色
                        initial = name[0].upper() if name else "?"
                        bg_color = colors[(i-1) % len(colors)]
                        
                        # 创建企业卡片 - 使用首字母显示替代Logo
                        unicorn_badge = '<span class="unicorn-tag">独角兽</span>' if is_unicorn else ''
                        value_text = f'<div class="company-value">{market_value}</div>' if market_value else ''
                        top_class = ' top-3' if i <= 3 else ''
                        
                        # 使用首字母代替Logo图片
                        st.markdown(f"""
                        <div class="rank-card">
                            <div class="rank-number{top_class}">{i}</div>
                            <div class="company-initial" style="background-color:{bg_color};">{initial}</div>
                            <div class="company-info">
                                <div class="company-name">{name}{unicorn_badge}</div>
                                <div class="company-desc">{desc}</div>
                                {value_text}
                            </div>
                            <span class="company-type">{company_type}</span>
                        </div>
                        """, unsafe_allow_html=True)
                    
                    st.markdown('</div>', unsafe_allow_html=True)
                    
                    # 独角兽企业展示
                    if unicorn_companies:
                        st.markdown("#### 🦄 新兴独角兽企业")
                        
                        # 创建独角兽企业卡片布局
                        col1, col2 = st.columns(2)
                        
                        # 生成随机颜色列表，用于企业首字母背景
                        colors = [
                            "#c026d3", "#9333ea", "#4f46e5", "#0ea5e9", "#059669", 
                            "#ca8a04", "#dc2626", "#2563eb", "#c2410c", "#0f766e"
                        ]
                        
                        for i, company in enumerate(unicorn_companies):
                            name = company.get('name', f'独角兽企业{i+1}')
                            founded = company.get('founded_year', '')
                            valuation = company.get('valuation', '')
                            desc = company.get('description', '')
                            core_business = company.get('core_business', '')
                            logo_url = company.get('logo_url', '')
                            
                            # 生成企业首字母和背景色
                            initial = name[0].upper() if name else "?"
                            bg_color = colors[i % len(colors)]
                            
                            with col1 if i % 2 == 0 else col2:
                                st.markdown(f"""
                                <div style="background-color:#f8fafc; padding:15px; border-radius:10px; 
                                            margin-bottom:15px; border-left:4px solid #c026d3;">
                                    <div style="display:flex; align-items:center; margin-bottom:10px;">
                                        <div style="width:40px; height:40px; border-radius:5px; margin-right:10px; 
                                                    background-color:{bg_color}; color:white; display:flex; 
                                                    justify-content:center; align-items:center; font-weight:bold; font-size:18px;">
                                            {initial}
                                        </div>
                                        <div>
                                            <div style="font-weight:bold; font-size:16px;">{name}</div>
                                            <div style="font-size:12px; color:#64748b;">成立于 {founded}</div>
                                        </div>
                                    </div>
                                    <div style="background-color:#fdf4ff; color:#c026d3; display:inline-block; 
                                                padding:3px 8px; border-radius:4px; font-size:13px; margin-bottom:8px;">
                                        估值: {valuation}
                                    </div>
                                    <div style="font-size:14px; margin-top:5px;">
                                        <strong>核心业务:</strong> {core_business}
                                    </div>
                                    <div style="font-size:13px; color:#4b5563; margin-top:5px;">
                                        {desc}
                                    </div>
                                </div>
                                """, unsafe_allow_html=True)
        
        # 选项卡5: 行业前景
        with tabs[4]:
            # 显示行业前景
            outlook = trend_analysis.get('outlook', '')
            if not outlook or len(outlook) < 100:
                outlook = "系统未能提供足够详细的行业前景分析。建议通过专业行业报告或咨询行业专家获取更深入的见解。"
            
            st.markdown("### 🔮 行业整体前景")
            st.info(outlook)
            
            # 机遇与挑战
            opportunities = trend_analysis.get('opportunities', [])
            challenges = trend_analysis.get('challenges', [])
            
            # 如果数据缺失，提供默认内容
            if not opportunities:
                opportunities = ["行业正在快速发展，带来新的就业机会和专业化方向。", 
                                  "技术创新不断涌现，为从业者提供学习和成长的空间。", 
                                  "跨界融合趋势明显，复合型人才将更具竞争力。"]
            
            if not challenges:
                challenges = ["行业竞争日益激烈，要求从业者不断提升专业能力。", 
                            "技术更新迭代速度加快，需要持续学习适应变化。", 
                            "人才供给增长，可能导致入职门槛逐渐提高。"]
            
            col1, col2 = st.columns(2)
            
            with col1:
                st.markdown("### 🌟 行业机遇")
                for i, opportunity in enumerate(opportunities, 1):
                    st.success(f"{i}. {opportunity}")
            
            with col2:
                st.markdown("### 🧗 行业挑战")
                for i, challenge in enumerate(challenges, 1):
                    st.warning(f"{i}. {challenge}")
            
            # 未来发展预测
            future_predictions = trend_analysis.get('future_predictions', [])
            if future_predictions:
                st.markdown("### 🔭 未来发展预测")
                
                for i, prediction in enumerate(future_predictions, 1):
                    prediction_text = prediction
                    prediction_year = ""
                    
                    if isinstance(prediction, dict):
                        prediction_text = prediction.get('content', '')
                        prediction_year = prediction.get('year', '')
                    
                    st.info(f"**{prediction_year if prediction_year else f'预测{i}'}**: {prediction_text}")

def trend_analysis_page():
    """行业趋势分析页面"""
    st.title("行业趋势分析")
    
    # 设置当前页面标识，用于下拉框的唯一键
    st.session_state['_current_page'] = "trend_analysis"
    
    # 检查是否已有配置信息
    if not st.session_state.get('job_desc'):
        st.warning("⚠️ 请先在「个人配置」中设置目标职位信息")
        st.button("前往个人配置", on_click=lambda: st._set_query_params(page="个人配置"))
        return
    
    # 添加地区选择功能，新增地区并调整顺序
    regions = {
        "中国": "CN", 
        "美国": "US", 
        "欧盟": "EU", 
        "日本": "JP",
        "英国": "UK",
        "印度": "IN",
        "全球": "GLOBAL"
    }
    
    # 从侧边栏获取地区设置
    selected_region = st.sidebar.selectbox(
        "选择分析地区:",
        options=list(regions.keys()),
        index=0,  # 默认选择中国
        key="region_selector"
    )
    
    # 保存选择的地区代码
    region_code = regions[selected_region]
    
    # 清晰显示当前选择的地区并添加提示
    region_warning = ""
    if region_code == "GLOBAL":
        region_warning = "（注意：全球分析可能需要较长时间）"
    
    st.info(f"🌍 当前分析地区: **{selected_region}** {region_warning}", icon="🌍")
    
    # 检查是否已有分析结果，以及结果是否与当前选择的地区匹配
    has_valid_result = False
    if ('results' in st.session_state and 
        'trend_analysis' in st.session_state.get('results', {}) and
        'region' in st.session_state.get('results', {}).get('trend_analysis', {}) and
        st.session_state.get('results', {}).get('trend_analysis', {}).get('region') == region_code):
        has_valid_result = True
    
    if not has_valid_result:
        # 使用统一的个人信息预览组件
        show_profile_preview(expanded=False)
        
        # 提供直接分析按钮
        analyze_button_text = "🔍 分析行业趋势"
        if region_code == "GLOBAL":
            analyze_button_text = "🔍 分析全球行业趋势（可能需要较长时间）"
        
        if st.button(analyze_button_text, help=f"分析{selected_region}地区的行业发展趋势"):
            # 全球分析显示更明显的提示
            if region_code == "GLOBAL":
                with st.spinner("正在进行全球行业趋势分析，这可能需要1-2分钟..."):
                    _perform_trend_analysis(region_code, selected_region)
            else:
                with st.spinner(f"正在分析{selected_region}地区的行业趋势..."):
                    _perform_trend_analysis(region_code, selected_region)
    else:
        # 从结果中获取趋势分析部分
        results = st.session_state.results
        
        # 显示分析结果
        display_trend_analysis_results(results.get('trend_analysis', {}))

# 添加辅助函数单独处理分析过程
def _perform_trend_analysis(region_code, selected_region):
    try:
        # 从session获取信息
        job_desc = st.session_state.get('job_desc', '')
        
        # 进行分析，传入地区参数
        trend_analysis = system.trend_engine.analyze_industry_trends(
            job_desc, 
            region=region_code
        )
        
        # 保存地区信息到结果中
        trend_analysis['region'] = region_code
        
        # 临时保存结果，但不覆盖完整分析的结果
        if 'results' not in st.session_state:
            st.session_state.results = {}
        
        st.session_state.results['trend_analysis'] = trend_analysis
        
        # 显示分析结果
        display_trend_analysis_results(trend_analysis)
        
    except Exception as e:
        st.error(f"分析过程中发生错误: {str(e)}")
        import traceback
        st.error(traceback.format_exc())

def career_planning_page():
    """职业规划页面"""
    st.title("职业发展规划")
    
    # 设置当前页面标识，用于下拉框的唯一键
    st.session_state['_current_page'] = "career_planning"
    
    # 检查是否已有所需配置信息
    if not (st.session_state.get('resume_text') and st.session_state.get('job_desc')):
        st.warning("⚠️ 请先在「个人配置」中设置您的简历和目标职位信息")
        st.button("前往个人配置", on_click=lambda: st._set_query_params(page="个人配置"))
        return
    
    # 检查是否已有分析结果
    if 'results' not in st.session_state or not st.session_state.get('results', {}).get('career_paths'):
        # 使用统一的个人信息预览组件
        show_profile_preview(expanded=False)
        
        # 提供直接分析按钮
        if st.button("📊 生成职业发展路径", help="基于您的技能和目标职位规划职业发展路径"):
            with st.spinner("正在生成职业发展路径..."):
                try:
                    # 从session获取信息
                    resume = st.session_state.get('resume_text', '')
                    job = st.session_state.get('job_desc', '')
                    goals = st.session_state.get('career_goals', '')
                    
                    # 先分析技能
                    user_skills, job_skills, _ = system.skill_diagnosis.analyze_resume_and_job_together(
                        resume, job
                    )
                    
                    # 生成职业路径
                    career_paths = system.career_path.recommend_career_paths(
                        user_skills, job_skills, goals
                    )
                    
                    # 临时保存结果，但不覆盖完整分析的结果
                    if 'results' not in st.session_state:
                        st.session_state.results = {}
                    
                    st.session_state.results['career_paths'] = career_paths
                    
                    # 显示职业路径
                    if career_paths:
                        st.success("职业路径生成成功！")
                        
                        # 首先显示职业目标分析
                        if 'goal_analysis' in career_paths[0]:
                            st.markdown("### 🎯 职业目标分析")
                            st.info(career_paths[0]['goal_analysis'])
                        
                        # 添加路径选择器
                        if len(career_paths) > 1:
                            path_options = [f"路径 {i+1}: {path.get('name', '职业发展路径')}" for i, path in enumerate(career_paths)]
                            selected_path_index = st.radio("选择职业路径查看详情:", path_options, index=0)
                            selected_path_index = int(selected_path_index.split(':')[0].replace('路径', '').strip()) - 1
                            path = career_paths[selected_path_index]
                        else:
                            path = career_paths[0]
                        
                        # 显示所选路径详情 - 使用简化的HTML结构
                        st.subheader(path.get('name', '职业发展路径'))
                        st.write(path.get('description', ''))
                        
                        # 显示职业路径时间线 - 简化显示方式，避免复杂HTML
                        positions = path.get('positions', [])
                        if positions:
                            st.markdown("### 🛤️ 职业发展时间线")
                            
                            for i, pos in enumerate(positions, 1):
                                title = pos.get('title', '')
                                timeframe = pos.get('timeframe', '')
                                description = pos.get('description', '')
                                skills_to_develop = pos.get('skills_to_develop', [])
                                
                                # 使用Streamlit原生组件而不是复杂HTML
                                st.markdown(f"**步骤 {i}: {title}**")
                                if timeframe:
                                    st.markdown(f"*时间范围: {timeframe}*")
                                if description:
                                    st.write(description)
                                
                                if skills_to_develop:
                                    st.markdown("**需要发展的技能:**")
                                    # 使用简单的列表展示
                                    for skill in skills_to_develop:
                                        st.markdown(f"- {skill}")
                                
                                # 如果不是最后一个职位，添加分隔线
                                if i < len(positions):
                                    st.markdown("---")
                        
                        # 创建两列布局显示优势和挑战
                        col1, col2 = st.columns(2)
                        
                        with col1:
                            advantages = path.get('advantages', [])
                            if advantages:
                                st.markdown("### 💪 优势")
                                for adv in advantages:
                                    st.markdown(f"""
                                    <div style="background-color:#e8f5e9; padding:10px; border-radius:5px; 
                                                margin-bottom:10px; border-left:3px solid #4CAF50;">
                                        ✅ {adv}
                                    </div>
                                    """, unsafe_allow_html=True)
                    
                        with col2:
                            challenges = path.get('challenges', [])
                            if challenges:
                                st.markdown("### 🧗‍♀️ 挑战")
                                for challenge in challenges:
                                    st.markdown(f"""
                                    <div style="background-color:#fff8e1; padding:10px; border-radius:5px; 
                                                margin-bottom:10px; border-left:3px solid #FFC107;">
                                        ⚠️ {challenge}
                                    </div>
                                    """, unsafe_allow_html=True)
                    
                        # 显示应对策略
                        if 'strategies' in path:
                            st.markdown("### 🔑 成功策略")
                            
                            strategies = path['strategies']
                            if isinstance(strategies, list):
                                for i, strategy in enumerate(strategies, 1):
                                    st.info(f"策略 {i}: {strategy}")
                            elif isinstance(strategies, str):
                                st.info(strategies)
                    
                except Exception as e:
                    st.error(f"生成过程中发生错误: {str(e)}")
                    st.error(traceback.format_exc())
    else:
        # 从结果中获取职业规划部分
        results = st.session_state.results
        
        # 显示职业规划内容
        if 'career_paths' in results:
            career_paths = results['career_paths']
            
            if career_paths:
                # 首先显示职业目标分析
                if 'goal_analysis' in career_paths[0]:
                    st.markdown("### 🎯 职业目标分析")
                    st.info(career_paths[0]['goal_analysis'])
                
                # 添加路径选择器
                if len(career_paths) > 1:
                    path_options = [f"路径 {i+1}: {path.get('name', '职业发展路径')}" for i, path in enumerate(career_paths)]
                    selected_path_index = st.radio("选择职业路径查看详情:", path_options, index=0)
                    selected_path_index = int(selected_path_index.split(':')[0].replace('路径', '').strip()) - 1
                    path = career_paths[selected_path_index]
                else:
                    path = career_paths[0]
                
                # 显示所选路径详情 - 使用简化的HTML结构
                st.subheader(path.get('name', '职业发展路径'))
                st.write(path.get('description', ''))
                
                # 显示职业路径时间线 - 简化显示方式，避免复杂HTML
                positions = path.get('positions', [])
                if positions:
                    st.markdown("### 🛤️ 职业发展时间线")
                    
                    for i, pos in enumerate(positions, 1):
                        title = pos.get('title', '')
                        timeframe = pos.get('timeframe', '')
                        description = pos.get('description', '')
                        skills_to_develop = pos.get('skills_to_develop', [])
                        
                        # 使用Streamlit原生组件而不是复杂HTML
                        st.markdown(f"**步骤 {i}: {title}**")
                        if timeframe:
                            st.markdown(f"*时间范围: {timeframe}*")
                        if description:
                            st.write(description)
                        
                        if skills_to_develop:
                            st.markdown("**需要发展的技能:**")
                            # 使用简单的列表展示
                            for skill in skills_to_develop:
                                st.markdown(f"- {skill}")
                        
                        # 如果不是最后一个职位，添加分隔线
                        if i < len(positions):
                            st.markdown("---")
                
                # 创建两列布局显示优势和挑战
                col1, col2 = st.columns(2)
                
                with col1:
                    advantages = path.get('advantages', [])
                    if advantages:
                        st.markdown("### 💪 优势")
                        for adv in advantages:
                            st.success(adv)
                
                with col2:
                    challenges = path.get('challenges', [])
                    if challenges:
                        st.markdown("### 🧗‍♀️ 挑战")
                        for challenge in challenges:
                            st.warning(challenge)
                
                # 显示应对策略
                if 'strategies' in path:
                    st.markdown("### 🔑 成功策略")
                    
                    strategies = path['strategies']
                    if isinstance(strategies, list):
                        for i, strategy in enumerate(strategies, 1):
                            st.info(f"策略 {i}: {strategy}")
                    elif isinstance(strategies, str):
                        st.info(strategies)

def learning_plan_page():
    """学习计划页面"""
    st.title("个性化学习计划")
    
    # 设置当前页面标识，用于下拉框的唯一键
    st.session_state['_current_page'] = "learning_plan"
    
    # 检查是否已有所需配置信息
    if not (st.session_state.get('resume_text') and st.session_state.get('job_desc')):
        st.warning("⚠️ 请先在「个人配置」中设置您的简历和目标职位信息")
        st.button("前往个人配置", on_click=lambda: st._set_query_params(page="个人配置"))
        return
    
    # 检查是否已有分析结果
    if 'results' not in st.session_state or not st.session_state.get('results', {}).get('learning_plan'):
        # 使用统一的个人信息预览组件
        show_profile_preview(expanded=False)
        
        # 使用session中保存的时间线
        timeline = st.session_state.get('timeline_months', 3)
        
        # 创建内容预览选项卡
        if st.checkbox("查看详细内容", value=False):
            tab1, tab2 = st.tabs(["简历详情", "职位详情"])
            
            with tab1:
                resume_text = st.session_state.get('resume_text', '')
                st.markdown(f"""
                <div class="preview-container">
                {resume_text}
                </div>
                """, unsafe_allow_html=True)
                
            with tab2:
                job_desc = st.session_state.get('job_desc', '')
                st.markdown(f"""
                <div class="preview-container">
                {job_desc}
                </div>
                """, unsafe_allow_html=True)
        
        # 提供直接分析按钮
        if st.button("📚 生成学习计划", help=f"生成{timeline}个月的个性化学习计划"):
            with st.spinner("正在生成个性化学习计划..."):
                try:
                    # 从session获取信息
                    resume = st.session_state.get('resume_text', '')
                    job = st.session_state.get('job_desc', '')
                    goals = st.session_state.get('career_goals', '')
                    
                    # 先分析技能
                    user_skills, job_skills, match_analysis = system.skill_diagnosis.analyze_resume_and_job_together(
                        resume, job
                    )
                    
                    # 生成学习计划
                    learning_plan = system.learning_plan.generate_learning_plan(
                        match_analysis, goals, timeline
                    )
                    
                    # 临时保存结果，但不覆盖完整分析的结果
                    if 'results' not in st.session_state:
                        st.session_state.results = {}
                    
                    st.session_state.results['learning_plan'] = learning_plan
                    
                    # 显示学习计划
                    if learning_plan:
                        st.success(f"已生成{timeline}个月学习计划！")
                        
                        # 显示计划概要
                        skills_plan = learning_plan.get('skills_plan', {})
                        if isinstance(skills_plan, dict) and 'skills' in skills_plan:
                            skills = skills_plan['skills']
                            
                            if skills:
                                st.subheader("技能学习计划")
                                for skill in skills:
                                    st.write(f"- {skill.get('skill_name', '')}: {skill.get('priority', '普通')}优先级")
                                    
                except Exception as e:
                    st.error(f"生成过程中发生错误: {str(e)}")
    else:
        # 从结果中获取学习计划部分
        results = st.session_state.results
        
        # 显示学习计划内容
        if 'learning_plan' in results:
            learning_plan = results['learning_plan']
            
            # 显示计划概要
            timeline = learning_plan.get('timeline', 3)
            st.subheader(f"{timeline}个月学习计划")
            
            # 获取技能计划
            skills_plan = learning_plan.get('skills_plan', {})
            if isinstance(skills_plan, dict) and 'skills' in skills_plan:
                skills = skills_plan['skills']
                
                if skills:
                    # 创建技能表格
                    skill_data = []
                    for skill in skills:
                        skill_data.append({
                            "技能名称": skill.get('skill_name', ''),
                            "优先级": skill.get('priority', ''),
                            "分配时间(月)": skill.get('months_allocated', 0),
                            "当前水平": skill.get('current_level', 0),
                            "目标水平": skill.get('target_level', 0)
                        })
                    
                    if skill_data:
                        skill_df = pd.DataFrame(skill_data)
                        st.dataframe(skill_df, use_container_width=True)

# 页面标题
st.title("🚀 AI职业发展智能匹配系统")
st.markdown("---")

# 侧边栏
with st.sidebar:
    st.header("导航菜单")
    page = st.radio(
        "选择功能",
        ["个人配置", "首页", "技能诊断", "趋势分析", "职业规划", "学习计划"],
        index=0  # 默认选择个人配置
    )
    
    st.markdown("---")
    st.markdown("### 关于系统")
    st.info("本系统利用AI技术分析行业趋势和个人技能，提供精准的职业发展建议和学习规划。")

# 如果session中没有配置信息且用户不在配置页，提示先配置
if (page != "个人配置" and 
    not (st.session_state.get('resume_text') and 
         st.session_state.get('job_desc'))):
    st.warning("⚠️ 请先在「个人配置」中设置您的简历和目标职位信息")
    page = "个人配置"
    
# 根据选择显示不同页面
if page == "个人配置":
    user_profile_page()
elif page == "首页":
    home_page()
elif page == "技能诊断":
    skill_diagnosis_page()
elif page == "趋势分析":
    trend_analysis_page()
elif page == "职业规划":
    career_planning_page()
elif page == "学习计划":
    learning_plan_page()

# 添加页脚
st.markdown("---")
st.markdown("© 2025 AI职业发展智能匹配系统 | 提供精准职业规划与学习指导")

# 添加检查结果语言的函数
def check_chinese_content(data, key=""):
    """检查数据中是否包含中文内容"""
    if isinstance(data, dict):
        for k, v in data.items():
            current_key = f"{key}.{k}" if key else k
            if isinstance(v, (dict, list)):
                if not check_chinese_content(v, current_key):
                    return False
            elif isinstance(v, str) and len(v) > 10:
                # 检查字符串中中文字符的比例
                chinese_chars = sum(1 for c in v if '\u4e00' <= c <= '\u9fff')
                if chinese_chars / len(v) < 0.1:  # 如果中文字符占比低于10%
                    print(f"键 {current_key} 的内容缺少中文: {v[:30]}...")
                    return False
    elif isinstance(data, list):
        for i, item in enumerate(data):
            current_key = f"{key}[{i}]"
            if isinstance(item, (dict, list)):
                if not check_chinese_content(item, current_key):
                    return False
            elif isinstance(item, str) and len(item) > 10:
                chinese_chars = sum(1 for c in item if '\u4e00' <= c <= '\u9fff')
                if chinese_chars / len(item) < 0.1:
                    print(f"键 {current_key} 的内容缺少中文: {item[:30]}...")
                    return False
    return True
